src/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCTargetDesc.cpp

   1 //===-- HexagonMCTargetDesc.cpp - Hexagon Target Descriptions -------------===//
   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 Hexagon specific target descriptions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "HexagonMCTargetDesc.h"
  15 #include "HexagonMCAsmInfo.h"
  16 #include "MCTargetDesc/HexagonInstPrinter.h"
  17 #include "MCTargetDesc/HexagonMCInst.h"
  18 #include "llvm/MC/MCCodeGenInfo.h"
  19 #include "llvm/MC/MCELFStreamer.h"
  20 #include "llvm/MC/MCInstrInfo.h"
  21 #include "llvm/MC/MCRegisterInfo.h"
  22 #include "llvm/MC/MCStreamer.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MachineLocation.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/TargetRegistry.h"
  27
  28 using namespace llvm;
  29
  30 #define GET_INSTRINFO_MC_DESC
  31 #include "HexagonGenInstrInfo.inc"
  32
  33 #define GET_SUBTARGETINFO_MC_DESC
  34 #include "HexagonGenSubtargetInfo.inc"
  35
  36 #define GET_REGINFO_MC_DESC
  37 #include "HexagonGenRegisterInfo.inc"
  38
  39 static MCInstrInfo *createHexagonMCInstrInfo() {
  40   MCInstrInfo *X = new MCInstrInfo();
  41   InitHexagonMCInstrInfo(X);
  42   return X;
  43 }
  44
  45 static MCRegisterInfo *createHexagonMCRegisterInfo(StringRef TT) {
  46   MCRegisterInfo *X = new MCRegisterInfo();
  47   InitHexagonMCRegisterInfo(X, Hexagon::R0);
  48   return X;
  49 }
  50
  51 static MCStreamer *
  52 createHexagonELFStreamer(MCContext &Context, MCAsmBackend &MAB,
  53                          raw_ostream &OS, MCCodeEmitter *CE,
  54                          bool RelaxAll) {
  55   MCELFStreamer *ES = new MCELFStreamer(Context, MAB, OS, CE);
  56   return ES;
  57 }
  58
  59
  60 static MCSubtargetInfo *
  61 createHexagonMCSubtargetInfo(StringRef TT, StringRef CPU, StringRef FS) {
  62   MCSubtargetInfo *X = new MCSubtargetInfo();
  63   InitHexagonMCSubtargetInfo(X, TT, CPU, FS);
  64   return X;
  65 }
  66
  67 static MCAsmInfo *createHexagonMCAsmInfo(const MCRegisterInfo &MRI,
  68                                          StringRef TT) {
  69   MCAsmInfo *MAI = new HexagonMCAsmInfo(TT);
  70
  71   // VirtualFP = (R30 + #0).
  72   MCCFIInstruction Inst =
  73       MCCFIInstruction::createDefCfa(nullptr, Hexagon::R30, 0);
  74   MAI->addInitialFrameState(Inst);
  75
  76   return MAI;
  77 }
  78
  79 static MCStreamer *createMCStreamer(Target const &T, StringRef TT,
  80                                     MCContext &Context, MCAsmBackend &MAB,
  81                                     raw_ostream &OS, MCCodeEmitter *Emitter,
  82                                     MCSubtargetInfo const &STI, bool RelaxAll) {
  83   MCStreamer *ES = createHexagonELFStreamer(Context, MAB, OS, Emitter, RelaxAll);
  84   new MCTargetStreamer(*ES);
  85   return ES;
  86 }
  87
  88
  89 static MCCodeGenInfo *createHexagonMCCodeGenInfo(StringRef TT, Reloc::Model RM,
  90                                                  CodeModel::Model CM,
  91                                                  CodeGenOpt::Level OL) {
  92   MCCodeGenInfo *X = new MCCodeGenInfo();
  93   // For the time being, use static relocations, since there's really no
  94   // support for PIC yet.
  95   X->InitMCCodeGenInfo(Reloc::Static, CM, OL);
  96   return X;
  97 }
  98 static MCInstPrinter *createHexagonMCInstPrinter(const Target &T,
  99                                                  unsigned SyntaxVariant,
 100                                                  const MCAsmInfo &MAI,
 101                                                  const MCInstrInfo &MII,
 102                                                  const MCRegisterInfo &MRI,
 103                                                  const MCSubtargetInfo &STI) {
 104     return new HexagonInstPrinter(MAI, MII, MRI);
 105 }
 106
 107 // Force static initialization.
 108 extern "C" void LLVMInitializeHexagonTargetMC() {
 109   // Register the MC asm info.
 110   RegisterMCAsmInfoFn X(TheHexagonTarget, createHexagonMCAsmInfo);
 111
 112   // Register the MC codegen info.
 113   TargetRegistry::RegisterMCCodeGenInfo(TheHexagonTarget,
 114                                         createHexagonMCCodeGenInfo);
 115
 116   // Register the MC instruction info.
 117   TargetRegistry::RegisterMCInstrInfo(TheHexagonTarget,
 118                                       createHexagonMCInstrInfo);
 119   HexagonMCInst::MCII.reset (createHexagonMCInstrInfo());
 120
 121   // Register the MC register info.
 122   TargetRegistry::RegisterMCRegInfo(TheHexagonTarget,
 123                                     createHexagonMCRegisterInfo);
 124
 125   // Register the MC subtarget info.
 126   TargetRegistry::RegisterMCSubtargetInfo(TheHexagonTarget,
 127                                           createHexagonMCSubtargetInfo);
 128
 129   // Register the MC Code Emitter
 130   TargetRegistry::RegisterMCCodeEmitter(TheHexagonTarget,
 131                                         createHexagonMCCodeEmitter);
 132
 133   // Register the MC Inst Printer
 134   TargetRegistry::RegisterMCInstPrinter(TheHexagonTarget,
 135                                         createHexagonMCInstPrinter);
 136
 137   // Register the asm backend
 138   TargetRegistry::RegisterMCAsmBackend(TheHexagonTarget,
 139                                        createHexagonAsmBackend);
 140
 141   // Register the obj streamer
 142   TargetRegistry::RegisterMCObjectStreamer(TheHexagonTarget, createMCStreamer);
 143 }