|
120
|
1 //===-- LanaiMCTargetDesc.cpp - Lanai Target Descriptions -----------------===//
|
|
|
2 //
|
|
147
|
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
|
|
120
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8 //
|
|
|
9 // This file provides Lanai specific target descriptions.
|
|
|
10 //
|
|
|
11 //===----------------------------------------------------------------------===//
|
|
|
12
|
|
|
13 #include "LanaiMCTargetDesc.h"
|
|
147
|
14 #include "LanaiInstPrinter.h"
|
|
120
|
15 #include "LanaiMCAsmInfo.h"
|
|
147
|
16 #include "TargetInfo/LanaiTargetInfo.h"
|
|
121
|
17 #include "llvm/ADT/StringRef.h"
|
|
|
18 #include "llvm/ADT/Triple.h"
|
|
|
19 #include "llvm/MC/MCInst.h"
|
|
120
|
20 #include "llvm/MC/MCInstrAnalysis.h"
|
|
|
21 #include "llvm/MC/MCInstrInfo.h"
|
|
121
|
22 #include "llvm/MC/MCRegisterInfo.h"
|
|
120
|
23 #include "llvm/MC/MCStreamer.h"
|
|
|
24 #include "llvm/MC/MCSubtargetInfo.h"
|
|
|
25 #include "llvm/Support/ErrorHandling.h"
|
|
|
26 #include "llvm/Support/TargetRegistry.h"
|
|
121
|
27 #include <cstdint>
|
|
|
28 #include <string>
|
|
120
|
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 = CPU;
|
|
|
56 if (CPUName.empty())
|
|
|
57 CPUName = "generic";
|
|
|
58
|
|
|
59 return createLanaiMCSubtargetInfoImpl(TT, CPUName, FS);
|
|
|
60 }
|
|
|
61
|
|
|
62 static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
|
|
121
|
63 std::unique_ptr<MCAsmBackend> &&MAB,
|
|
147
|
64 std::unique_ptr<MCObjectWriter> &&OW,
|
|
121
|
65 std::unique_ptr<MCCodeEmitter> &&Emitter,
|
|
|
66 bool RelaxAll) {
|
|
120
|
67 if (!T.isOSBinFormatELF())
|
|
|
68 llvm_unreachable("OS not supported");
|
|
|
69
|
|
147
|
70 return createELFStreamer(Context, std::move(MAB), std::move(OW),
|
|
|
71 std::move(Emitter), RelaxAll);
|
|
120
|
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);
|
|
121
|
81 return nullptr;
|
|
120
|
82 }
|
|
|
83
|
|
|
84 static MCRelocationInfo *createLanaiElfRelocation(const Triple &TheTriple,
|
|
|
85 MCContext &Ctx) {
|
|
|
86 return createMCRelocationInfo(TheTriple, Ctx);
|
|
|
87 }
|
|
|
88
|
|
|
89 namespace {
|
|
121
|
90
|
|
120
|
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
|
|
|
101 if (Info->get(Inst.getOpcode()).OpInfo[0].OperandType ==
|
|
|
102 MCOI::OPERAND_PCREL) {
|
|
|
103 int64_t Imm = Inst.getOperand(0).getImm();
|
|
|
104 Target = Addr + Size + Imm;
|
|
|
105 return true;
|
|
|
106 } else {
|
|
|
107 int64_t Imm = Inst.getOperand(0).getImm();
|
|
|
108
|
|
|
109 // Skip case where immediate is 0 as that occurs in file that isn't linked
|
|
|
110 // and the branch target inferred would be wrong.
|
|
|
111 if (Imm == 0)
|
|
|
112 return false;
|
|
|
113
|
|
|
114 Target = Imm;
|
|
|
115 return true;
|
|
|
116 }
|
|
|
117 }
|
|
|
118 };
|
|
121
|
119
|
|
120
|
120 } // end anonymous namespace
|
|
|
121
|
|
|
122 static MCInstrAnalysis *createLanaiInstrAnalysis(const MCInstrInfo *Info) {
|
|
|
123 return new LanaiMCInstrAnalysis(Info);
|
|
|
124 }
|
|
|
125
|
|
|
126 extern "C" void LLVMInitializeLanaiTargetMC() {
|
|
|
127 // Register the MC asm info.
|
|
|
128 RegisterMCAsmInfo<LanaiMCAsmInfo> X(getTheLanaiTarget());
|
|
|
129
|
|
|
130 // Register the MC instruction info.
|
|
|
131 TargetRegistry::RegisterMCInstrInfo(getTheLanaiTarget(),
|
|
|
132 createLanaiMCInstrInfo);
|
|
|
133
|
|
|
134 // Register the MC register info.
|
|
|
135 TargetRegistry::RegisterMCRegInfo(getTheLanaiTarget(),
|
|
|
136 createLanaiMCRegisterInfo);
|
|
|
137
|
|
|
138 // Register the MC subtarget info.
|
|
|
139 TargetRegistry::RegisterMCSubtargetInfo(getTheLanaiTarget(),
|
|
|
140 createLanaiMCSubtargetInfo);
|
|
|
141
|
|
|
142 // Register the MC code emitter
|
|
|
143 TargetRegistry::RegisterMCCodeEmitter(getTheLanaiTarget(),
|
|
121
|
144 createLanaiMCCodeEmitter);
|
|
120
|
145
|
|
|
146 // Register the ASM Backend
|
|
|
147 TargetRegistry::RegisterMCAsmBackend(getTheLanaiTarget(),
|
|
|
148 createLanaiAsmBackend);
|
|
|
149
|
|
|
150 // Register the MCInstPrinter.
|
|
|
151 TargetRegistry::RegisterMCInstPrinter(getTheLanaiTarget(),
|
|
|
152 createLanaiMCInstPrinter);
|
|
|
153
|
|
|
154 // Register the ELF streamer.
|
|
|
155 TargetRegistry::RegisterELFStreamer(getTheLanaiTarget(), createMCStreamer);
|
|
|
156
|
|
|
157 // Register the MC relocation info.
|
|
|
158 TargetRegistry::RegisterMCRelocationInfo(getTheLanaiTarget(),
|
|
|
159 createLanaiElfRelocation);
|
|
|
160
|
|
|
161 // Register the MC instruction analyzer.
|
|
|
162 TargetRegistry::RegisterMCInstrAnalysis(getTheLanaiTarget(),
|
|
|
163 createLanaiInstrAnalysis);
|
|
|
164 }
|
