lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp

   1 //===-- MipsMCTargetDesc.cpp - Mips 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 Mips specific target descriptions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "MipsMCTargetDesc.h"
  15 #include "InstPrinter/MipsInstPrinter.h"
  16 #include "MipsMCAsmInfo.h"
  17 #include "MipsTargetStreamer.h"
  18 #include "llvm/MC/MCCodeGenInfo.h"
  19 #include "llvm/MC/MCELF.h"
  20 #include "llvm/MC/MCELFStreamer.h"
  21 #include "llvm/MC/MCInstrInfo.h"
  22 #include "llvm/MC/MCRegisterInfo.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCSymbol.h"
  25 #include "llvm/MC/MachineLocation.h"
  26 #include "llvm/Support/CommandLine.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include "llvm/Support/FormattedStream.h"
  29 #include "llvm/Support/TargetRegistry.h"
  30
  31 #define GET_INSTRINFO_MC_DESC
  32 #include "MipsGenInstrInfo.inc"
  33
  34 #define GET_SUBTARGETINFO_MC_DESC
  35 #include "MipsGenSubtargetInfo.inc"
  36
  37 #define GET_REGINFO_MC_DESC
  38 #include "MipsGenRegisterInfo.inc"
  39
  40 using namespace llvm;
  41
  42 static cl::opt<bool> PrintHackDirectives("print-hack-directives",
  43                                          cl::init(false), cl::Hidden);
  44
  45 static std::string ParseMipsTriple(StringRef TT, StringRef CPU) {
  46   std::string MipsArchFeature;
  47   size_t DashPosition = 0;
  48   StringRef TheTriple;
  49
  50   // Let's see if there is a dash, like mips-unknown-linux.
  51   DashPosition = TT.find('-');
  52
  53   if (DashPosition == StringRef::npos) {
  54     // No dash, we check the string size.
  55     TheTriple = TT.substr(0);
  56   } else {
  57     // We are only interested in substring before dash.
  58     TheTriple = TT.substr(0,DashPosition);
  59   }
  60
  61   if (TheTriple == "mips" || TheTriple == "mipsel") {
  62     if (CPU.empty() || CPU == "mips32") {
  63       MipsArchFeature = "+mips32";
  64     } else if (CPU == "mips32r2") {
  65       MipsArchFeature = "+mips32r2";
  66     }
  67   } else {
  68       if (CPU.empty() || CPU == "mips64") {
  69         MipsArchFeature = "+mips64";
  70       } else if (CPU == "mips64r2") {
  71         MipsArchFeature = "+mips64r2";
  72       }
  73   }
  74   return MipsArchFeature;
  75 }
  76
  77 static MCInstrInfo *createMipsMCInstrInfo() {
  78   MCInstrInfo *X = new MCInstrInfo();
  79   InitMipsMCInstrInfo(X);
  80   return X;
  81 }
  82
  83 static MCRegisterInfo *createMipsMCRegisterInfo(StringRef TT) {
  84   MCRegisterInfo *X = new MCRegisterInfo();
  85   InitMipsMCRegisterInfo(X, Mips::RA);
  86   return X;
  87 }
  88
  89 static MCSubtargetInfo *createMipsMCSubtargetInfo(StringRef TT, StringRef CPU,
  90                                                   StringRef FS) {
  91   std::string ArchFS = ParseMipsTriple(TT,CPU);
  92   if (!FS.empty()) {
  93     if (!ArchFS.empty())
  94       ArchFS = ArchFS + "," + FS.str();
  95     else
  96       ArchFS = FS;
  97   }
  98   MCSubtargetInfo *X = new MCSubtargetInfo();
  99   InitMipsMCSubtargetInfo(X, TT, CPU, ArchFS);
 100   return X;
 101 }
 102
 103 static MCAsmInfo *createMipsMCAsmInfo(const MCRegisterInfo &MRI, StringRef TT) {
 104   MCAsmInfo *MAI = new MipsMCAsmInfo(TT);
 105
 106   unsigned SP = MRI.getDwarfRegNum(Mips::SP, true);
 107   MCCFIInstruction Inst = MCCFIInstruction::createDefCfa(0, SP, 0);
 108   MAI->addInitialFrameState(Inst);
 109
 110   return MAI;
 111 }
 112
 113 static MCCodeGenInfo *createMipsMCCodeGenInfo(StringRef TT, Reloc::Model RM,
 114                                               CodeModel::Model CM,
 115                                               CodeGenOpt::Level OL) {
 116   MCCodeGenInfo *X = new MCCodeGenInfo();
 117   if (CM == CodeModel::JITDefault)
 118     RM = Reloc::Static;
 119   else if (RM == Reloc::Default)
 120     RM = Reloc::PIC_;
 121   X->InitMCCodeGenInfo(RM, CM, OL);
 122   return X;
 123 }
 124
 125 static MCInstPrinter *createMipsMCInstPrinter(const Target &T,
 126                                               unsigned SyntaxVariant,
 127                                               const MCAsmInfo &MAI,
 128                                               const MCInstrInfo &MII,
 129                                               const MCRegisterInfo &MRI,
 130                                               const MCSubtargetInfo &STI) {
 131   return new MipsInstPrinter(MAI, MII, MRI);
 132 }
 133
 134 namespace {
 135 class MipsTargetAsmStreamer : public MipsTargetStreamer {
 136   formatted_raw_ostream &OS;
 137
 138 public:
 139   MipsTargetAsmStreamer(formatted_raw_ostream &OS);
 140   virtual void emitMipsHackELFFlags(unsigned Flags);
 141   virtual void emitMipsHackSTOCG(MCSymbol *Sym, unsigned Val);
 142 };
 143
 144 MipsTargetAsmStreamer::MipsTargetAsmStreamer(formatted_raw_ostream &OS)
 145     : OS(OS) {}
 146
 147 void MipsTargetAsmStreamer::emitMipsHackELFFlags(unsigned Flags) {
 148   if (!PrintHackDirectives)
 149     return;
 150
 151   OS << "\t.mips_hack_elf_flags 0x";
 152   OS.write_hex(Flags);
 153   OS << '\n';
 154 }
 155 void MipsTargetAsmStreamer::emitMipsHackSTOCG(MCSymbol *Sym, unsigned Val) {
 156   if (!PrintHackDirectives)
 157     return;
 158
 159   OS << "\t.mips_hack_stocg ";
 160   OS << Sym->getName();
 161   OS << ", ";
 162   OS << Val;
 163   OS << '\n';
 164 }
 165
 166 class MipsTargetELFStreamer : public MipsTargetStreamer {
 167 public:
 168   MCELFStreamer &getStreamer();
 169   MipsTargetELFStreamer();
 170   virtual void emitMipsHackELFFlags(unsigned Flags);
 171   virtual void emitMipsHackSTOCG(MCSymbol *Sym, unsigned Val);
 172 };
 173
 174 MipsTargetELFStreamer::MipsTargetELFStreamer() {}
 175
 176 MCELFStreamer &MipsTargetELFStreamer::getStreamer() {
 177   return static_cast<MCELFStreamer &>(*Streamer);
 178 }
 179
 180 void MipsTargetELFStreamer::emitMipsHackELFFlags(unsigned Flags) {
 181   MCAssembler &MCA = getStreamer().getAssembler();
 182   MCA.setELFHeaderEFlags(Flags);
 183 }
 184
 185 // Set a symbol's STO flags
 186 void MipsTargetELFStreamer::emitMipsHackSTOCG(MCSymbol *Sym, unsigned Val) {
 187   MCSymbolData &Data = getStreamer().getOrCreateSymbolData(Sym);
 188   // The "other" values are stored in the last 6 bits of the second byte
 189   // The traditional defines for STO values assume the full byte and thus
 190   // the shift to pack it.
 191   MCELF::setOther(Data, Val >> 2);
 192 }
 193 }
 194
 195 static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
 196                                     MCContext &Context, MCAsmBackend &MAB,
 197                                     raw_ostream &OS, MCCodeEmitter *Emitter,
 198                                     bool RelaxAll, bool NoExecStack) {
 199   MipsTargetELFStreamer *S = new MipsTargetELFStreamer();
 200   return createELFStreamer(Context, S, MAB, OS, Emitter, RelaxAll, NoExecStack);
 201 }
 202
 203 static MCStreamer *
 204 createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
 205                     bool isVerboseAsm, bool useLoc, bool useCFI,
 206                     bool useDwarfDirectory, MCInstPrinter *InstPrint,
 207                     MCCodeEmitter *CE, MCAsmBackend *TAB, bool ShowInst) {
 208   MipsTargetAsmStreamer *S = new MipsTargetAsmStreamer(OS);
 209
 210   return llvm::createAsmStreamer(Ctx, S, OS, isVerboseAsm, useLoc, useCFI,
 211                                  useDwarfDirectory, InstPrint, CE, TAB,
 212                                  ShowInst);
 213 }
 214
 215 extern "C" void LLVMInitializeMipsTargetMC() {
 216   // Register the MC asm info.
 217   RegisterMCAsmInfoFn X(TheMipsTarget, createMipsMCAsmInfo);
 218   RegisterMCAsmInfoFn Y(TheMipselTarget, createMipsMCAsmInfo);
 219   RegisterMCAsmInfoFn A(TheMips64Target, createMipsMCAsmInfo);
 220   RegisterMCAsmInfoFn B(TheMips64elTarget, createMipsMCAsmInfo);
 221
 222   // Register the MC codegen info.
 223   TargetRegistry::RegisterMCCodeGenInfo(TheMipsTarget,
 224                                         createMipsMCCodeGenInfo);
 225   TargetRegistry::RegisterMCCodeGenInfo(TheMipselTarget,
 226                                         createMipsMCCodeGenInfo);
 227   TargetRegistry::RegisterMCCodeGenInfo(TheMips64Target,
 228                                         createMipsMCCodeGenInfo);
 229   TargetRegistry::RegisterMCCodeGenInfo(TheMips64elTarget,
 230                                         createMipsMCCodeGenInfo);
 231
 232   // Register the MC instruction info.
 233   TargetRegistry::RegisterMCInstrInfo(TheMipsTarget, createMipsMCInstrInfo);
 234   TargetRegistry::RegisterMCInstrInfo(TheMipselTarget, createMipsMCInstrInfo);
 235   TargetRegistry::RegisterMCInstrInfo(TheMips64Target, createMipsMCInstrInfo);
 236   TargetRegistry::RegisterMCInstrInfo(TheMips64elTarget,
 237                                       createMipsMCInstrInfo);
 238
 239   // Register the MC register info.
 240   TargetRegistry::RegisterMCRegInfo(TheMipsTarget, createMipsMCRegisterInfo);
 241   TargetRegistry::RegisterMCRegInfo(TheMipselTarget, createMipsMCRegisterInfo);
 242   TargetRegistry::RegisterMCRegInfo(TheMips64Target, createMipsMCRegisterInfo);
 243   TargetRegistry::RegisterMCRegInfo(TheMips64elTarget,
 244                                     createMipsMCRegisterInfo);
 245
 246   // Register the MC Code Emitter
 247   TargetRegistry::RegisterMCCodeEmitter(TheMipsTarget,
 248                                         createMipsMCCodeEmitterEB);
 249   TargetRegistry::RegisterMCCodeEmitter(TheMipselTarget,
 250                                         createMipsMCCodeEmitterEL);
 251   TargetRegistry::RegisterMCCodeEmitter(TheMips64Target,
 252                                         createMipsMCCodeEmitterEB);
 253   TargetRegistry::RegisterMCCodeEmitter(TheMips64elTarget,
 254                                         createMipsMCCodeEmitterEL);
 255
 256   // Register the object streamer.
 257   TargetRegistry::RegisterMCObjectStreamer(TheMipsTarget, createMCStreamer);
 258   TargetRegistry::RegisterMCObjectStreamer(TheMipselTarget, createMCStreamer);
 259   TargetRegistry::RegisterMCObjectStreamer(TheMips64Target, createMCStreamer);
 260   TargetRegistry::RegisterMCObjectStreamer(TheMips64elTarget,
 261                                            createMCStreamer);
 262
 263   // Register the asm streamer.
 264   TargetRegistry::RegisterAsmStreamer(TheMipsTarget, createMCAsmStreamer);
 265   TargetRegistry::RegisterAsmStreamer(TheMipselTarget, createMCAsmStreamer);
 266   TargetRegistry::RegisterAsmStreamer(TheMips64Target, createMCAsmStreamer);
 267   TargetRegistry::RegisterAsmStreamer(TheMips64elTarget, createMCAsmStreamer);
 268
 269   // Register the asm backend.
 270   TargetRegistry::RegisterMCAsmBackend(TheMipsTarget,
 271                                        createMipsAsmBackendEB32);
 272   TargetRegistry::RegisterMCAsmBackend(TheMipselTarget,
 273                                        createMipsAsmBackendEL32);
 274   TargetRegistry::RegisterMCAsmBackend(TheMips64Target,
 275                                        createMipsAsmBackendEB64);
 276   TargetRegistry::RegisterMCAsmBackend(TheMips64elTarget,
 277                                        createMipsAsmBackendEL64);
 278
 279   // Register the MC subtarget info.
 280   TargetRegistry::RegisterMCSubtargetInfo(TheMipsTarget,
 281                                           createMipsMCSubtargetInfo);
 282   TargetRegistry::RegisterMCSubtargetInfo(TheMipselTarget,
 283                                           createMipsMCSubtargetInfo);
 284   TargetRegistry::RegisterMCSubtargetInfo(TheMips64Target,
 285                                           createMipsMCSubtargetInfo);
 286   TargetRegistry::RegisterMCSubtargetInfo(TheMips64elTarget,
 287                                           createMipsMCSubtargetInfo);
 288
 289   // Register the MCInstPrinter.
 290   TargetRegistry::RegisterMCInstPrinter(TheMipsTarget,
 291                                         createMipsMCInstPrinter);
 292   TargetRegistry::RegisterMCInstPrinter(TheMipselTarget,
 293                                         createMipsMCInstPrinter);
 294   TargetRegistry::RegisterMCInstPrinter(TheMips64Target,
 295                                         createMipsMCInstPrinter);
 296   TargetRegistry::RegisterMCInstPrinter(TheMips64elTarget,
 297                                         createMipsMCInstPrinter);
 298 }