include/llvm/Target/TargetMachineImpls.h

   1 //===-- llvm/Target/TargetMachineImpls.h - Target Descriptions --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the entry point to getting access to the various target
  11 // machine implementations available to LLVM.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TARGET_TARGETMACHINEIMPLS_H
  16 #define LLVM_TARGET_TARGETMACHINEIMPLS_H
  17
  18 namespace llvm {
  19   /// Command line options shared between TargetMachine implementations -
  20   /// these should go in their own header eventually.
  21   ///
  22   extern bool PrintMachineCode;
  23
  24   class TargetMachine;
  25   class Module;
  26   class IntrinsicLowering;
  27
  28   // allocateCTargetMachine - Allocate and return a subclass of TargetMachine
  29   // that implements emits C code.  This takes ownership of the
  30   // IntrinsicLowering pointer, deleting it when the target machine is
  31   // destroyed.
  32   //
  33   TargetMachine *allocateCTargetMachine(const Module &M,
  34                                         IntrinsicLowering *IL = 0);
  35
  36   // allocateSparcV9TargetMachine - Allocate and return a subclass of
  37   // TargetMachine that implements the 64-bit Sparc backend.  This takes
  38   // ownership of the IntrinsicLowering pointer, deleting it when the target
  39   // machine is destroyed.
  40   //
  41   TargetMachine *allocateSparcV9TargetMachine(const Module &M,
  42                                             IntrinsicLowering *IL = 0);
  43
  44   // allocateSparcV8TargetMachine - Allocate and return a subclass of
  45   // TargetMachine that implements the 32-bit Sparc backend.  This takes
  46   // ownership of the IntrinsicLowering pointer, deleting it when the target
  47   // machine is destroyed.
  48   //
  49   TargetMachine *allocateSparcV8TargetMachine(const Module &M,
  50                                               IntrinsicLowering *IL = 0);
  51
  52   // allocateX86TargetMachine - Allocate and return a subclass of TargetMachine
  53   // that implements the X86 backend.  This takes ownership of the
  54   // IntrinsicLowering pointer, deleting it when the target machine is
  55   // destroyed.
  56   //
  57   TargetMachine *allocateX86TargetMachine(const Module &M,
  58                                           IntrinsicLowering *IL = 0);
  59
  60   // allocatePowerPCTargetMachine - Allocate and return a subclass
  61   // of TargetMachine that implements the PowerPC backend.  This takes
  62   // ownership of the IntrinsicLowering pointer, deleting it when
  63   // the target machine is destroyed.
  64   //
  65   TargetMachine *allocatePowerPCTargetMachine(const Module &M,
  66                                               IntrinsicLowering *IL = 0);
  67 } // End llvm namespace
  68
  69 #endif