contrib/llvm/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h

   1 //===-- X86MCTargetDesc.h - X86 Target Descriptions -------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file provides X86 specific target descriptions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_TARGET_X86_MCTARGETDESC_X86MCTARGETDESC_H
  15 #define LLVM_LIB_TARGET_X86_MCTARGETDESC_X86MCTARGETDESC_H
  16
  17 #include "llvm/MC/MCStreamer.h"
  18 #include "llvm/Support/DataTypes.h"
  19 #include <string>
  20
  21 namespace llvm {
  22 class MCAsmBackend;
  23 class MCCodeEmitter;
  24 class MCContext;
  25 class MCInstrInfo;
  26 class MCObjectTargetWriter;
  27 class MCObjectWriter;
  28 class MCRegisterInfo;
  29 class MCSubtargetInfo;
  30 class MCRelocationInfo;
  31 class MCTargetOptions;
  32 class Target;
  33 class Triple;
  34 class StringRef;
  35 class raw_ostream;
  36 class raw_pwrite_stream;
  37
  38 Target &getTheX86_32Target();
  39 Target &getTheX86_64Target();
  40
  41 /// Flavour of dwarf regnumbers
  42 ///
  43 namespace DWARFFlavour {
  44   enum {
  45     X86_64 = 0, X86_32_DarwinEH = 1, X86_32_Generic = 2
  46   };
  47 }
  48
  49 ///  Native X86 register numbers
  50 ///
  51 namespace N86 {
  52   enum {
  53     EAX = 0, ECX = 1, EDX = 2, EBX = 3, ESP = 4, EBP = 5, ESI = 6, EDI = 7
  54   };
  55 }
  56
  57 namespace X86_MC {
  58 std::string ParseX86Triple(const Triple &TT);
  59
  60 unsigned getDwarfRegFlavour(const Triple &TT, bool isEH);
  61
  62 void initLLVMToSEHAndCVRegMapping(MCRegisterInfo *MRI);
  63
  64 /// Create a X86 MCSubtargetInfo instance. This is exposed so Asm parser, etc.
  65 /// do not need to go through TargetRegistry.
  66 MCSubtargetInfo *createX86MCSubtargetInfo(const Triple &TT, StringRef CPU,
  67                                           StringRef FS);
  68 }
  69
  70 MCCodeEmitter *createX86MCCodeEmitter(const MCInstrInfo &MCII,
  71                                       const MCRegisterInfo &MRI,
  72                                       MCContext &Ctx);
  73
  74 MCAsmBackend *createX86_32AsmBackend(const Target &T,
  75                                      const MCSubtargetInfo &STI,
  76                                      const MCRegisterInfo &MRI,
  77                                      const MCTargetOptions &Options);
  78 MCAsmBackend *createX86_64AsmBackend(const Target &T,
  79                                      const MCSubtargetInfo &STI,
  80                                      const MCRegisterInfo &MRI,
  81                                      const MCTargetOptions &Options);
  82
  83 /// Implements X86-only directives for assembly emission.
  84 MCTargetStreamer *createX86AsmTargetStreamer(MCStreamer &S,
  85                                              formatted_raw_ostream &OS,
  86                                              MCInstPrinter *InstPrint,
  87                                              bool isVerboseAsm);
  88
  89 /// Implements X86-only directives for object files.
  90 MCTargetStreamer *createX86ObjectTargetStreamer(MCStreamer &OS,
  91                                                 const MCSubtargetInfo &STI);
  92
  93 /// Construct an X86 Windows COFF machine code streamer which will generate
  94 /// PE/COFF format object files.
  95 ///
  96 /// Takes ownership of \p AB and \p CE.
  97 MCStreamer *createX86WinCOFFStreamer(MCContext &C,
  98                                      std::unique_ptr<MCAsmBackend> &&AB,
  99                                      std::unique_ptr<MCObjectWriter> &&OW,
 100                                      std::unique_ptr<MCCodeEmitter> &&CE,
 101                                      bool RelaxAll,
 102                                      bool IncrementalLinkerCompatible);
 103
 104 /// Construct an X86 Mach-O object writer.
 105 std::unique_ptr<MCObjectTargetWriter>
 106 createX86MachObjectWriter(bool Is64Bit, uint32_t CPUType, uint32_t CPUSubtype);
 107
 108 /// Construct an X86 ELF object writer.
 109 std::unique_ptr<MCObjectTargetWriter>
 110 createX86ELFObjectWriter(bool IsELF64, uint8_t OSABI, uint16_t EMachine);
 111 /// Construct an X86 Win COFF object writer.
 112 std::unique_ptr<MCObjectTargetWriter>
 113 createX86WinCOFFObjectWriter(bool Is64Bit);
 114
 115 /// Returns the sub or super register of a specific X86 register.
 116 /// e.g. getX86SubSuperRegister(X86::EAX, 16) returns X86::AX.
 117 /// Aborts on error.
 118 unsigned getX86SubSuperRegister(unsigned, unsigned, bool High=false);
 119
 120 /// Returns the sub or super register of a specific X86 register.
 121 /// Like getX86SubSuperRegister() but returns 0 on error.
 122 unsigned getX86SubSuperRegisterOrZero(unsigned, unsigned,
 123                                       bool High = false);
 124
 125 } // End llvm namespace
 126
 127
 128 // Defines symbolic names for X86 registers.  This defines a mapping from
 129 // register name to register number.
 130 //
 131 #define GET_REGINFO_ENUM
 132 #include "X86GenRegisterInfo.inc"
 133
 134 // Defines symbolic names for the X86 instructions.
 135 //
 136 #define GET_INSTRINFO_ENUM
 137 #define GET_INSTRINFO_MC_HELPER_DECLS
 138 #include "X86GenInstrInfo.inc"
 139
 140 #define GET_SUBTARGETINFO_ENUM
 141 #include "X86GenSubtargetInfo.inc"
 142
 143 #endif