1 //===-- LanaiMCTargetDesc.cpp - Lanai 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 // This file provides Lanai specific target descriptions. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "LanaiMCTargetDesc.h" 14 #include "LanaiInstPrinter.h" 15 #include "LanaiMCAsmInfo.h" 16 #include "TargetInfo/LanaiTargetInfo.h" 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/MC/MCInst.h" 20 #include "llvm/MC/MCInstrAnalysis.h" 21 #include "llvm/MC/MCInstrInfo.h" 22 #include "llvm/MC/MCRegisterInfo.h" 23 #include "llvm/MC/MCStreamer.h" 24 #include "llvm/MC/MCSubtargetInfo.h" 25 #include "llvm/MC/TargetRegistry.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include <cstdint> 28 #include <string> 29 30 #define GET_INSTRINFO_MC_DESC 31 #include "LanaiGenInstrInfo.inc" 32 33 #define GET_SUBTARGETINFO_MC_DESC 34 #include "LanaiGenSubtargetInfo.inc" 35 36 #define GET_REGINFO_MC_DESC 37 #include "LanaiGenRegisterInfo.inc" 38 39 using namespace llvm; 40 41 static MCInstrInfo *createLanaiMCInstrInfo() { 42 MCInstrInfo *X = new MCInstrInfo(); 43 InitLanaiMCInstrInfo(X); 44 return X; 45 } 46 47 static MCRegisterInfo *createLanaiMCRegisterInfo(const Triple & /*TT*/) { 48 MCRegisterInfo *X = new MCRegisterInfo(); 49 InitLanaiMCRegisterInfo(X, Lanai::RCA, 0, 0, Lanai::PC); 50 return X; 51 } 52 53 static MCSubtargetInfo * 54 createLanaiMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS) { 55 std::string CPUName = std::string(CPU); 56 if (CPUName.empty()) 57 CPUName = "generic"; 58 59 return createLanaiMCSubtargetInfoImpl(TT, CPUName, /*TuneCPU*/ CPUName, FS); 60 } 61 62 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context, 63 std::unique_ptr<MCAsmBackend> &&MAB, 64 std::unique_ptr<MCObjectWriter> &&OW, 65 std::unique_ptr<MCCodeEmitter> &&Emitter, 66 bool RelaxAll) { 67 if (!T.isOSBinFormatELF()) 68 llvm_unreachable("OS not supported"); 69 70 return createELFStreamer(Context, std::move(MAB), std::move(OW), 71 std::move(Emitter), RelaxAll); 72 } 73 74 static MCInstPrinter *createLanaiMCInstPrinter(const Triple & /*T*/, 75 unsigned SyntaxVariant, 76 const MCAsmInfo &MAI, 77 const MCInstrInfo &MII, 78 const MCRegisterInfo &MRI) { 79 if (SyntaxVariant == 0) 80 return new LanaiInstPrinter(MAI, MII, MRI); 81 return nullptr; 82 } 83 84 static MCRelocationInfo *createLanaiElfRelocation(const Triple &TheTriple, 85 MCContext &Ctx) { 86 return createMCRelocationInfo(TheTriple, Ctx); 87 } 88 89 namespace { 90 91 class LanaiMCInstrAnalysis : public MCInstrAnalysis { 92 public: 93 explicit LanaiMCInstrAnalysis(const MCInstrInfo *Info) 94 : MCInstrAnalysis(Info) {} 95 96 bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size, 97 uint64_t &Target) const override { 98 if (Inst.getNumOperands() == 0) 99 return false; 100 if (!isConditionalBranch(Inst) && !isUnconditionalBranch(Inst) && 101 !isCall(Inst)) 102 return false; 103 104 if (Info->get(Inst.getOpcode()).OpInfo[0].OperandType == 105 MCOI::OPERAND_PCREL) { 106 int64_t Imm = Inst.getOperand(0).getImm(); 107 Target = Addr + Size + Imm; 108 return true; 109 } else { 110 int64_t Imm = Inst.getOperand(0).getImm(); 111 112 // Skip case where immediate is 0 as that occurs in file that isn't linked 113 // and the branch target inferred would be wrong. 114 if (Imm == 0) 115 return false; 116 117 Target = Imm; 118 return true; 119 } 120 } 121 }; 122 123 } // end anonymous namespace 124 125 static MCInstrAnalysis *createLanaiInstrAnalysis(const MCInstrInfo *Info) { 126 return new LanaiMCInstrAnalysis(Info); 127 } 128 129 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeLanaiTargetMC() { 130 // Register the MC asm info. 131 RegisterMCAsmInfo<LanaiMCAsmInfo> X(getTheLanaiTarget()); 132 133 // Register the MC instruction info. 134 TargetRegistry::RegisterMCInstrInfo(getTheLanaiTarget(), 135 createLanaiMCInstrInfo); 136 137 // Register the MC register info. 138 TargetRegistry::RegisterMCRegInfo(getTheLanaiTarget(), 139 createLanaiMCRegisterInfo); 140 141 // Register the MC subtarget info. 142 TargetRegistry::RegisterMCSubtargetInfo(getTheLanaiTarget(), 143 createLanaiMCSubtargetInfo); 144 145 // Register the MC code emitter 146 TargetRegistry::RegisterMCCodeEmitter(getTheLanaiTarget(), 147 createLanaiMCCodeEmitter); 148 149 // Register the ASM Backend 150 TargetRegistry::RegisterMCAsmBackend(getTheLanaiTarget(), 151 createLanaiAsmBackend); 152 153 // Register the MCInstPrinter. 154 TargetRegistry::RegisterMCInstPrinter(getTheLanaiTarget(), 155 createLanaiMCInstPrinter); 156 157 // Register the ELF streamer. 158 TargetRegistry::RegisterELFStreamer(getTheLanaiTarget(), createMCStreamer); 159 160 // Register the MC relocation info. 161 TargetRegistry::RegisterMCRelocationInfo(getTheLanaiTarget(), 162 createLanaiElfRelocation); 163 164 // Register the MC instruction analyzer. 165 TargetRegistry::RegisterMCInstrAnalysis(getTheLanaiTarget(), 166 createLanaiInstrAnalysis); 167 } 168