1 //===-- AMDGPUMCTargetDesc.cpp - AMDGPU Target Descriptions ---------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 /// \file 10 /// This file provides AMDGPU specific target descriptions. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "AMDGPUMCTargetDesc.h" 15 #include "AMDGPUELFStreamer.h" 16 #include "AMDGPUMCAsmInfo.h" 17 #include "AMDGPUTargetStreamer.h" 18 #include "InstPrinter/AMDGPUInstPrinter.h" 19 #include "SIDefines.h" 20 #include "llvm/MC/MCAsmBackend.h" 21 #include "llvm/MC/MCCodeEmitter.h" 22 #include "llvm/MC/MCContext.h" 23 #include "llvm/MC/MCInstrAnalysis.h" 24 #include "llvm/MC/MCInstrInfo.h" 25 #include "llvm/MC/MCObjectWriter.h" 26 #include "llvm/MC/MCRegisterInfo.h" 27 #include "llvm/MC/MCStreamer.h" 28 #include "llvm/MC/MCSubtargetInfo.h" 29 #include "llvm/MC/MachineLocation.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include "llvm/Support/TargetRegistry.h" 32 33 using namespace llvm; 34 35 #define GET_INSTRINFO_MC_DESC 36 #include "AMDGPUGenInstrInfo.inc" 37 38 #define GET_SUBTARGETINFO_MC_DESC 39 #include "AMDGPUGenSubtargetInfo.inc" 40 41 #define NoSchedModel NoSchedModelR600 42 #define GET_SUBTARGETINFO_MC_DESC 43 #include "R600GenSubtargetInfo.inc" 44 #undef NoSchedModelR600 45 46 #define GET_REGINFO_MC_DESC 47 #include "AMDGPUGenRegisterInfo.inc" 48 49 #define GET_REGINFO_MC_DESC 50 #include "R600GenRegisterInfo.inc" 51 52 static MCInstrInfo *createAMDGPUMCInstrInfo() { 53 MCInstrInfo *X = new MCInstrInfo(); 54 InitAMDGPUMCInstrInfo(X); 55 return X; 56 } 57 58 static MCRegisterInfo *createAMDGPUMCRegisterInfo(const Triple &TT) { 59 MCRegisterInfo *X = new MCRegisterInfo(); 60 if (TT.getArch() == Triple::r600) 61 InitR600MCRegisterInfo(X, 0); 62 else 63 InitAMDGPUMCRegisterInfo(X, 0); 64 return X; 65 } 66 67 static MCSubtargetInfo * 68 createAMDGPUMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) { 69 if (TT.getArch() == Triple::r600) 70 return createR600MCSubtargetInfoImpl(TT, CPU, FS); 71 return createAMDGPUMCSubtargetInfoImpl(TT, CPU, FS); 72 } 73 74 static MCInstPrinter *createAMDGPUMCInstPrinter(const Triple &T, 75 unsigned SyntaxVariant, 76 const MCAsmInfo &MAI, 77 const MCInstrInfo &MII, 78 const MCRegisterInfo &MRI) { 79 if (T.getArch() == Triple::r600) 80 return new R600InstPrinter(MAI, MII, MRI); 81 else 82 return new AMDGPUInstPrinter(MAI, MII, MRI); 83 } 84 85 static MCTargetStreamer *createAMDGPUAsmTargetStreamer(MCStreamer &S, 86 formatted_raw_ostream &OS, 87 MCInstPrinter *InstPrint, 88 bool isVerboseAsm) { 89 return new AMDGPUTargetAsmStreamer(S, OS); 90 } 91 92 static MCTargetStreamer * createAMDGPUObjectTargetStreamer( 93 MCStreamer &S, 94 const MCSubtargetInfo &STI) { 95 return new AMDGPUTargetELFStreamer(S, STI); 96 } 97 98 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context, 99 std::unique_ptr<MCAsmBackend> &&MAB, 100 std::unique_ptr<MCObjectWriter> &&OW, 101 std::unique_ptr<MCCodeEmitter> &&Emitter, 102 bool RelaxAll) { 103 return createAMDGPUELFStreamer(T, Context, std::move(MAB), std::move(OW), 104 std::move(Emitter), RelaxAll); 105 } 106 107 namespace { 108 109 class AMDGPUMCInstrAnalysis : public MCInstrAnalysis { 110 public: 111 explicit AMDGPUMCInstrAnalysis(const MCInstrInfo *Info) 112 : MCInstrAnalysis(Info) {} 113 114 bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size, 115 uint64_t &Target) const override { 116 if (Inst.getNumOperands() == 0 || !Inst.getOperand(0).isImm() || 117 Info->get(Inst.getOpcode()).OpInfo[0].OperandType != 118 MCOI::OPERAND_PCREL) 119 return false; 120 121 int64_t Imm = Inst.getOperand(0).getImm(); 122 // Our branches take a simm16, but we need two extra bits to account for 123 // the factor of 4. 124 APInt SignedOffset(18, Imm * 4, true); 125 Target = (SignedOffset.sext(64) + Addr + Size).getZExtValue(); 126 return true; 127 } 128 }; 129 130 } // end anonymous namespace 131 132 static MCInstrAnalysis *createAMDGPUMCInstrAnalysis(const MCInstrInfo *Info) { 133 return new AMDGPUMCInstrAnalysis(Info); 134 } 135 136 extern "C" void LLVMInitializeAMDGPUTargetMC() { 137 138 TargetRegistry::RegisterMCInstrInfo(getTheGCNTarget(), createAMDGPUMCInstrInfo); 139 TargetRegistry::RegisterMCInstrInfo(getTheAMDGPUTarget(), createR600MCInstrInfo); 140 for (Target *T : {&getTheAMDGPUTarget(), &getTheGCNTarget()}) { 141 RegisterMCAsmInfo<AMDGPUMCAsmInfo> X(*T); 142 143 TargetRegistry::RegisterMCRegInfo(*T, createAMDGPUMCRegisterInfo); 144 TargetRegistry::RegisterMCSubtargetInfo(*T, createAMDGPUMCSubtargetInfo); 145 TargetRegistry::RegisterMCInstPrinter(*T, createAMDGPUMCInstPrinter); 146 TargetRegistry::RegisterMCInstrAnalysis(*T, createAMDGPUMCInstrAnalysis); 147 TargetRegistry::RegisterMCAsmBackend(*T, createAMDGPUAsmBackend); 148 TargetRegistry::RegisterELFStreamer(*T, createMCStreamer); 149 } 150 151 // R600 specific registration 152 TargetRegistry::RegisterMCCodeEmitter(getTheAMDGPUTarget(), 153 createR600MCCodeEmitter); 154 TargetRegistry::RegisterObjectTargetStreamer( 155 getTheAMDGPUTarget(), createAMDGPUObjectTargetStreamer); 156 157 // GCN specific registration 158 TargetRegistry::RegisterMCCodeEmitter(getTheGCNTarget(), 159 createSIMCCodeEmitter); 160 161 TargetRegistry::RegisterAsmTargetStreamer(getTheGCNTarget(), 162 createAMDGPUAsmTargetStreamer); 163 TargetRegistry::RegisterObjectTargetStreamer( 164 getTheGCNTarget(), createAMDGPUObjectTargetStreamer); 165 } 166