lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

   1 //===-- PPCMCTargetDesc.cpp - PowerPC 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 PowerPC specific target descriptions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PPCMCTargetDesc.h"
  15 #include "InstPrinter/PPCInstPrinter.h"
  16 #include "PPCMCAsmInfo.h"
  17 #include "PPCTargetStreamer.h"
  18 #include "llvm/MC/MCCodeGenInfo.h"
  19 #include "llvm/MC/MCContext.h"
  20 #include "llvm/MC/MCELFStreamer.h"
  21 #include "llvm/MC/MCExpr.h"
  22 #include "llvm/MC/MCInstrInfo.h"
  23 #include "llvm/MC/MCRegisterInfo.h"
  24 #include "llvm/MC/MCStreamer.h"
  25 #include "llvm/MC/MCSubtargetInfo.h"
  26 #include "llvm/MC/MCSymbolELF.h"
  27 #include "llvm/MC/MachineLocation.h"
  28 #include "llvm/Support/ELF.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include "llvm/Support/FormattedStream.h"
  31 #include "llvm/Support/TargetRegistry.h"
  32
  33 using namespace llvm;
  34
  35 #define GET_INSTRINFO_MC_DESC
  36 #include "PPCGenInstrInfo.inc"
  37
  38 #define GET_SUBTARGETINFO_MC_DESC
  39 #include "PPCGenSubtargetInfo.inc"
  40
  41 #define GET_REGINFO_MC_DESC
  42 #include "PPCGenRegisterInfo.inc"
  43
  44 // Pin the vtable to this file.
  45 PPCTargetStreamer::~PPCTargetStreamer() {}
  46 PPCTargetStreamer::PPCTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {}
  47
  48 static MCInstrInfo *createPPCMCInstrInfo() {
  49   MCInstrInfo *X = new MCInstrInfo();
  50   InitPPCMCInstrInfo(X);
  51   return X;
  52 }
  53
  54 static MCRegisterInfo *createPPCMCRegisterInfo(const TargetTuple &TT) {
  55   bool isPPC64 = (TT.getArch() == TargetTuple::ppc64 ||
  56                   TT.getArch() == TargetTuple::ppc64le);
  57   unsigned Flavour = isPPC64 ? 0 : 1;
  58   unsigned RA = isPPC64 ? PPC::LR8 : PPC::LR;
  59
  60   MCRegisterInfo *X = new MCRegisterInfo();
  61   InitPPCMCRegisterInfo(X, RA, Flavour, Flavour);
  62   return X;
  63 }
  64
  65 static MCSubtargetInfo *createPPCMCSubtargetInfo(const TargetTuple &TT,
  66                                                  StringRef CPU, StringRef FS) {
  67   return createPPCMCSubtargetInfoImpl(TT, CPU, FS);
  68 }
  69
  70 static MCAsmInfo *createPPCMCAsmInfo(const MCRegisterInfo &MRI,
  71                                      const TargetTuple &TT) {
  72   bool isPPC64 = (TT.getArch() == TargetTuple::ppc64 ||
  73                   TT.getArch() == TargetTuple::ppc64le);
  74
  75   MCAsmInfo *MAI;
  76   if (TT.isOSDarwin())
  77     MAI = new PPCMCAsmInfoDarwin(isPPC64, TT);
  78   else
  79     MAI = new PPCELFMCAsmInfo(isPPC64, TT);
  80
  81   // Initial state of the frame pointer is R1.
  82   unsigned Reg = isPPC64 ? PPC::X1 : PPC::R1;
  83   MCCFIInstruction Inst =
  84       MCCFIInstruction::createDefCfa(nullptr, MRI.getDwarfRegNum(Reg, true), 0);
  85   MAI->addInitialFrameState(Inst);
  86
  87   return MAI;
  88 }
  89
  90 static MCCodeGenInfo *createPPCMCCodeGenInfo(const TargetTuple &TT,
  91                                              Reloc::Model RM,
  92                                              CodeModel::Model CM,
  93                                              CodeGenOpt::Level OL) {
  94   MCCodeGenInfo *X = new MCCodeGenInfo();
  95
  96   if (RM == Reloc::Default) {
  97     if (TT.isOSDarwin())
  98       RM = Reloc::DynamicNoPIC;
  99     else
 100       RM = Reloc::Static;
 101   }
 102   if (CM == CodeModel::Default) {
 103     if (!TT.isOSDarwin() && (TT.getArch() == TargetTuple::ppc64 ||
 104                              TT.getArch() == TargetTuple::ppc64le))
 105       CM = CodeModel::Medium;
 106   }
 107   X->initMCCodeGenInfo(RM, CM, OL);
 108   return X;
 109 }
 110
 111 namespace {
 112 class PPCTargetAsmStreamer : public PPCTargetStreamer {
 113   formatted_raw_ostream &OS;
 114
 115 public:
 116   PPCTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
 117       : PPCTargetStreamer(S), OS(OS) {}
 118   void emitTCEntry(const MCSymbol &S) override {
 119     OS << "\t.tc ";
 120     OS << S.getName();
 121     OS << "[TC],";
 122     OS << S.getName();
 123     OS << '\n';
 124   }
 125   void emitMachine(StringRef CPU) override {
 126     OS << "\t.machine " << CPU << '\n';
 127   }
 128   void emitAbiVersion(int AbiVersion) override {
 129     OS << "\t.abiversion " << AbiVersion << '\n';
 130   }
 131   void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
 132     const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
 133
 134     OS << "\t.localentry\t";
 135     S->print(OS, MAI);
 136     OS << ", ";
 137     LocalOffset->print(OS, MAI);
 138     OS << '\n';
 139   }
 140 };
 141
 142 class PPCTargetELFStreamer : public PPCTargetStreamer {
 143 public:
 144   PPCTargetELFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
 145   MCELFStreamer &getStreamer() {
 146     return static_cast<MCELFStreamer &>(Streamer);
 147   }
 148   void emitTCEntry(const MCSymbol &S) override {
 149     // Creates a R_PPC64_TOC relocation
 150     Streamer.EmitValueToAlignment(8);
 151     Streamer.EmitSymbolValue(&S, 8);
 152   }
 153   void emitMachine(StringRef CPU) override {
 154     // FIXME: Is there anything to do in here or does this directive only
 155     // limit the parser?
 156   }
 157   void emitAbiVersion(int AbiVersion) override {
 158     MCAssembler &MCA = getStreamer().getAssembler();
 159     unsigned Flags = MCA.getELFHeaderEFlags();
 160     Flags &= ~ELF::EF_PPC64_ABI;
 161     Flags |= (AbiVersion & ELF::EF_PPC64_ABI);
 162     MCA.setELFHeaderEFlags(Flags);
 163   }
 164   void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
 165     MCAssembler &MCA = getStreamer().getAssembler();
 166
 167     int64_t Res;
 168     if (!LocalOffset->evaluateAsAbsolute(Res, MCA))
 169       report_fatal_error(".localentry expression must be absolute.");
 170
 171     unsigned Encoded = ELF::encodePPC64LocalEntryOffset(Res);
 172     if (Res != ELF::decodePPC64LocalEntryOffset(Encoded))
 173       report_fatal_error(".localentry expression cannot be encoded.");
 174
 175     unsigned Other = S->getOther();
 176     Other &= ~ELF::STO_PPC64_LOCAL_MASK;
 177     Other |= Encoded;
 178     S->setOther(Other);
 179
 180     // For GAS compatibility, unless we already saw a .abiversion directive,
 181     // set e_flags to indicate ELFv2 ABI.
 182     unsigned Flags = MCA.getELFHeaderEFlags();
 183     if ((Flags & ELF::EF_PPC64_ABI) == 0)
 184       MCA.setELFHeaderEFlags(Flags | 2);
 185   }
 186   void emitAssignment(MCSymbol *S, const MCExpr *Value) override {
 187     auto *Symbol = cast<MCSymbolELF>(S);
 188     // When encoding an assignment to set symbol A to symbol B, also copy
 189     // the st_other bits encoding the local entry point offset.
 190     if (Value->getKind() != MCExpr::SymbolRef)
 191       return;
 192     const auto &RhsSym = cast<MCSymbolELF>(
 193         static_cast<const MCSymbolRefExpr *>(Value)->getSymbol());
 194     unsigned Other = Symbol->getOther();
 195     Other &= ~ELF::STO_PPC64_LOCAL_MASK;
 196     Other |= RhsSym.getOther() & ELF::STO_PPC64_LOCAL_MASK;
 197     Symbol->setOther(Other);
 198   }
 199 };
 200
 201 class PPCTargetMachOStreamer : public PPCTargetStreamer {
 202 public:
 203   PPCTargetMachOStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
 204   void emitTCEntry(const MCSymbol &S) override {
 205     llvm_unreachable("Unknown pseudo-op: .tc");
 206   }
 207   void emitMachine(StringRef CPU) override {
 208     // FIXME: We should update the CPUType, CPUSubType in the Object file if
 209     // the new values are different from the defaults.
 210   }
 211   void emitAbiVersion(int AbiVersion) override {
 212     llvm_unreachable("Unknown pseudo-op: .abiversion");
 213   }
 214   void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
 215     llvm_unreachable("Unknown pseudo-op: .localentry");
 216   }
 217 };
 218 }
 219
 220 static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
 221                                                  formatted_raw_ostream &OS,
 222                                                  MCInstPrinter *InstPrint,
 223                                                  bool isVerboseAsm) {
 224   return new PPCTargetAsmStreamer(S, OS);
 225 }
 226
 227 static MCTargetStreamer *
 228 createObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
 229   const TargetTuple &TT = STI.getTargetTuple();
 230   if (TT.isOSBinFormatELF())
 231     return new PPCTargetELFStreamer(S);
 232   return new PPCTargetMachOStreamer(S);
 233 }
 234
 235 static MCInstPrinter *createPPCMCInstPrinter(const TargetTuple &TT,
 236                                              unsigned SyntaxVariant,
 237                                              const MCAsmInfo &MAI,
 238                                              const MCInstrInfo &MII,
 239                                              const MCRegisterInfo &MRI) {
 240   return new PPCInstPrinter(MAI, MII, MRI, TT.isOSDarwin());
 241 }
 242
 243 extern "C" void LLVMInitializePowerPCTargetMC() {
 244   for (Target *T : {&ThePPC32Target, &ThePPC64Target, &ThePPC64LETarget}) {
 245     // Register the MC asm info.
 246     RegisterMCAsmInfoFn C(*T, createPPCMCAsmInfo);
 247
 248     // Register the MC codegen info.
 249     TargetRegistry::RegisterMCCodeGenInfo(*T, createPPCMCCodeGenInfo);
 250
 251     // Register the MC instruction info.
 252     TargetRegistry::RegisterMCInstrInfo(*T, createPPCMCInstrInfo);
 253
 254     // Register the MC register info.
 255     TargetRegistry::RegisterMCRegInfo(*T, createPPCMCRegisterInfo);
 256
 257     // Register the MC subtarget info.
 258     TargetRegistry::RegisterMCSubtargetInfo(*T, createPPCMCSubtargetInfo);
 259
 260     // Register the MC Code Emitter
 261     TargetRegistry::RegisterMCCodeEmitter(*T, createPPCMCCodeEmitter);
 262
 263     // Register the asm backend.
 264     TargetRegistry::RegisterMCAsmBackend(*T, createPPCAsmBackend);
 265
 266     // Register the object target streamer.
 267     TargetRegistry::RegisterObjectTargetStreamer(*T,
 268                                                  createObjectTargetStreamer);
 269
 270     // Register the asm target streamer.
 271     TargetRegistry::RegisterAsmTargetStreamer(*T, createAsmTargetStreamer);
 272
 273     // Register the MCInstPrinter.
 274     TargetRegistry::RegisterMCInstPrinter(*T, createPPCMCInstPrinter);
 275   }
 276 }