1//===-- MipsMCTargetDesc.cpp - Mips 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 Mips specific target descriptions.
10//
11//===----------------------------------------------------------------------===//
12
13#include "MipsMCTargetDesc.h"
14#include "MipsAsmBackend.h"
15#include "MipsBaseInfo.h"
16#include "MipsELFStreamer.h"
17#include "MipsInstPrinter.h"
18#include "MipsMCAsmInfo.h"
19#include "MipsMCOptions.h"
20#include "MipsTargetStreamer.h"
21#include "TargetInfo/MipsTargetInfo.h"
22#include "llvm/DebugInfo/CodeView/CodeView.h"
23#include "llvm/MC/MCCodeEmitter.h"
24#include "llvm/MC/MCELFStreamer.h"
25#include "llvm/MC/MCInstrAnalysis.h"
26#include "llvm/MC/MCInstrInfo.h"
27#include "llvm/MC/MCObjectWriter.h"
28#include "llvm/MC/MCRegisterInfo.h"
29#include "llvm/MC/MCSubtargetInfo.h"
30#include "llvm/MC/MCSymbol.h"
31#include "llvm/MC/TargetRegistry.h"
32#include "llvm/Option/LibraryOptions.h"
33#include "llvm/Support/Compiler.h"
34#include "llvm/Support/ErrorHandling.h"
35#include "llvm/Support/FormattedStream.h"
36#include "llvm/TargetParser/Triple.h"
37
38using namespace llvm;
39
40#define GET_INSTRINFO_MC_DESC
41#define ENABLE_INSTR_PREDICATE_VERIFIER
42#include "MipsGenInstrInfo.inc"
43
44#define GET_SUBTARGETINFO_MC_DESC
45#include "MipsGenSubtargetInfo.inc"
46
47#define GET_REGINFO_MC_DESC
48#include "MipsGenRegisterInfo.inc"
49
50#define GET_REGISTER_MATCHER
51#include "MipsGenAsmMatcher.inc"
52
53#define OPTIONS_STRUCT_DEFS
54#include "MipsMCOptions.inc"
55
56MCRegister MIPS_MC::getCOP0Register(const MCRegisterInfo &MRI,
57 unsigned Encoding) {
58 unsigned Reg = getCOP0RegNum(Encoding);
59 unsigned Sel = getCOP0Sel(Encoding);
60 assert(Reg < 32 && Sel < 8 && "Invalid COP0 register encoding");
61 // COP0's register class is ordered by selector, then register number.
62 return MRI.getRegClass(i: Mips::COP0RegClassID).getRegister(i: Sel * 32 + Reg);
63}
64
65MCRegister MIPS_MC::matchRegisterName(StringRef Name, const MCRegisterInfo &MRI,
66 unsigned RegClassID, unsigned AltIdx) {
67 MCRegister Reg = MatchRegisterAltName(Name, AltIdx);
68 if (!Reg)
69 Reg = MatchRegisterName(Name);
70 if (!Reg)
71 return MCRegister();
72
73 const MCRegisterClass &RC = MRI.getRegClass(i: RegClassID);
74 // GPR32 and GPR64 share names; select the requested width.
75 if (!RC.contains(Reg)) {
76 if (RegClassID == Mips::GPR32RegClassID &&
77 MRI.getRegClass(i: Mips::GPR64RegClassID).contains(Reg))
78 Reg = MRI.getSubReg(Reg, Idx: Mips::sub_32);
79 else if (RegClassID == Mips::GPR64RegClassID &&
80 MRI.getRegClass(i: Mips::GPR32RegClassID).contains(Reg))
81 Reg = MRI.getMatchingSuperReg(Reg, SubIdx: Mips::sub_32, RC: &RC);
82 }
83 return RC.contains(Reg) ? Reg : MCRegister();
84}
85
86int MIPS_MC::getCPURegisterIndex(StringRef Name, const MCRegisterInfo &MRI,
87 unsigned AltIdx, bool *IsDeprecated) {
88 if (IsDeprecated)
89 *IsDeprecated = false;
90
91 if (MCRegister Reg =
92 matchRegisterName(Name, MRI, RegClassID: Mips::GPR32RegClassID, AltIdx))
93 return MRI.getEncodingValue(Reg);
94
95 static const struct {
96 StringLiteral Name;
97 MCPhysReg Reg;
98 // NoRegAltName applies to all ABIs.
99 unsigned AltIdx;
100 } Aliases[] = {
101 {.Name: "AT", .Reg: Mips::R1, .AltIdx: Mips::NoRegAltName},
102 {.Name: "s8", .Reg: Mips::FP, .AltIdx: Mips::NoRegAltName},
103 {.Name: "kt0", .Reg: Mips::R26, .AltIdx: Mips::NABIRegAltName},
104 {.Name: "kt1", .Reg: Mips::R27, .AltIdx: Mips::NABIRegAltName},
105 };
106 for (const auto &Alias : Aliases)
107 if (Name == Alias.Name &&
108 (Alias.AltIdx == Mips::NoRegAltName || Alias.AltIdx == AltIdx))
109 return MRI.getEncodingValue(Reg: Alias.Reg);
110
111 // GNU also accepts t4-t7 for NABI's t0-t3.
112 if (AltIdx == Mips::NABIRegAltName) {
113 static const struct {
114 StringLiteral Name;
115 MCPhysReg Reg;
116 } Deprecated[] = {
117 {.Name: "t4", .Reg: Mips::R12},
118 {.Name: "t5", .Reg: Mips::R13},
119 {.Name: "t6", .Reg: Mips::R14},
120 {.Name: "t7", .Reg: Mips::R15},
121 };
122 for (const auto &Alias : Deprecated) {
123 if (Name == Alias.Name) {
124 if (IsDeprecated)
125 *IsDeprecated = true;
126 return MRI.getEncodingValue(Reg: Alias.Reg);
127 }
128 }
129 }
130 return -1;
131}
132
133void MIPS_MC::initLLVMToCVRegMapping(MCRegisterInfo *MRI) {
134 // Mapping from CodeView to MC register id.
135 static const struct {
136 codeview::RegisterId CVReg;
137 MCPhysReg Reg;
138 } RegMap[] = {
139 {.CVReg: codeview::RegisterId::MIPS_ZERO, .Reg: Mips::R0},
140 {.CVReg: codeview::RegisterId::MIPS_AT, .Reg: Mips::R1},
141 {.CVReg: codeview::RegisterId::MIPS_V0, .Reg: Mips::R2},
142 {.CVReg: codeview::RegisterId::MIPS_V1, .Reg: Mips::R3},
143 {.CVReg: codeview::RegisterId::MIPS_A0, .Reg: Mips::R4},
144 {.CVReg: codeview::RegisterId::MIPS_A1, .Reg: Mips::R5},
145 {.CVReg: codeview::RegisterId::MIPS_A2, .Reg: Mips::R6},
146 {.CVReg: codeview::RegisterId::MIPS_A3, .Reg: Mips::R7},
147 {.CVReg: codeview::RegisterId::MIPS_T0, .Reg: Mips::R8},
148 {.CVReg: codeview::RegisterId::MIPS_T1, .Reg: Mips::R9},
149 {.CVReg: codeview::RegisterId::MIPS_T2, .Reg: Mips::R10},
150 {.CVReg: codeview::RegisterId::MIPS_T3, .Reg: Mips::R11},
151 {.CVReg: codeview::RegisterId::MIPS_T4, .Reg: Mips::R12},
152 {.CVReg: codeview::RegisterId::MIPS_T5, .Reg: Mips::R13},
153 {.CVReg: codeview::RegisterId::MIPS_T6, .Reg: Mips::R14},
154 {.CVReg: codeview::RegisterId::MIPS_T7, .Reg: Mips::R15},
155 {.CVReg: codeview::RegisterId::MIPS_S0, .Reg: Mips::R16},
156 {.CVReg: codeview::RegisterId::MIPS_S1, .Reg: Mips::R17},
157 {.CVReg: codeview::RegisterId::MIPS_S2, .Reg: Mips::R18},
158 {.CVReg: codeview::RegisterId::MIPS_S3, .Reg: Mips::R19},
159 {.CVReg: codeview::RegisterId::MIPS_S4, .Reg: Mips::R20},
160 {.CVReg: codeview::RegisterId::MIPS_S5, .Reg: Mips::R21},
161 {.CVReg: codeview::RegisterId::MIPS_S6, .Reg: Mips::R22},
162 {.CVReg: codeview::RegisterId::MIPS_S7, .Reg: Mips::R23},
163 {.CVReg: codeview::RegisterId::MIPS_T8, .Reg: Mips::R24},
164 {.CVReg: codeview::RegisterId::MIPS_T9, .Reg: Mips::R25},
165 {.CVReg: codeview::RegisterId::MIPS_K0, .Reg: Mips::R26},
166 {.CVReg: codeview::RegisterId::MIPS_K1, .Reg: Mips::R27},
167 {.CVReg: codeview::RegisterId::MIPS_GP, .Reg: Mips::GP},
168 {.CVReg: codeview::RegisterId::MIPS_SP, .Reg: Mips::SP},
169 {.CVReg: codeview::RegisterId::MIPS_S8, .Reg: Mips::FP},
170 {.CVReg: codeview::RegisterId::MIPS_RA, .Reg: Mips::RA},
171 {.CVReg: codeview::RegisterId::MIPS_LO, .Reg: Mips::HI0},
172 {.CVReg: codeview::RegisterId::MIPS_HI, .Reg: Mips::LO0},
173 {.CVReg: codeview::RegisterId::MIPS_Fir, .Reg: Mips::FCR0},
174 {.CVReg: codeview::RegisterId::MIPS_Psr, .Reg: Mips::COP012}, // CP0.Status
175 {.CVReg: codeview::RegisterId::MIPS_F0, .Reg: Mips::F0},
176 {.CVReg: codeview::RegisterId::MIPS_F1, .Reg: Mips::F1},
177 {.CVReg: codeview::RegisterId::MIPS_F2, .Reg: Mips::F2},
178 {.CVReg: codeview::RegisterId::MIPS_F3, .Reg: Mips::F3},
179 {.CVReg: codeview::RegisterId::MIPS_F4, .Reg: Mips::F4},
180 {.CVReg: codeview::RegisterId::MIPS_F5, .Reg: Mips::F5},
181 {.CVReg: codeview::RegisterId::MIPS_F6, .Reg: Mips::F6},
182 {.CVReg: codeview::RegisterId::MIPS_F7, .Reg: Mips::F7},
183 {.CVReg: codeview::RegisterId::MIPS_F8, .Reg: Mips::F8},
184 {.CVReg: codeview::RegisterId::MIPS_F9, .Reg: Mips::F9},
185 {.CVReg: codeview::RegisterId::MIPS_F10, .Reg: Mips::F10},
186 {.CVReg: codeview::RegisterId::MIPS_F11, .Reg: Mips::F11},
187 {.CVReg: codeview::RegisterId::MIPS_F12, .Reg: Mips::F12},
188 {.CVReg: codeview::RegisterId::MIPS_F13, .Reg: Mips::F13},
189 {.CVReg: codeview::RegisterId::MIPS_F14, .Reg: Mips::F14},
190 {.CVReg: codeview::RegisterId::MIPS_F15, .Reg: Mips::F15},
191 {.CVReg: codeview::RegisterId::MIPS_F16, .Reg: Mips::F16},
192 {.CVReg: codeview::RegisterId::MIPS_F17, .Reg: Mips::F17},
193 {.CVReg: codeview::RegisterId::MIPS_F18, .Reg: Mips::F18},
194 {.CVReg: codeview::RegisterId::MIPS_F19, .Reg: Mips::F19},
195 {.CVReg: codeview::RegisterId::MIPS_F20, .Reg: Mips::F20},
196 {.CVReg: codeview::RegisterId::MIPS_F21, .Reg: Mips::F21},
197 {.CVReg: codeview::RegisterId::MIPS_F22, .Reg: Mips::F22},
198 {.CVReg: codeview::RegisterId::MIPS_F23, .Reg: Mips::F23},
199 {.CVReg: codeview::RegisterId::MIPS_F24, .Reg: Mips::F24},
200 {.CVReg: codeview::RegisterId::MIPS_F25, .Reg: Mips::F25},
201 {.CVReg: codeview::RegisterId::MIPS_F26, .Reg: Mips::F26},
202 {.CVReg: codeview::RegisterId::MIPS_F27, .Reg: Mips::F27},
203 {.CVReg: codeview::RegisterId::MIPS_F28, .Reg: Mips::F28},
204 {.CVReg: codeview::RegisterId::MIPS_F29, .Reg: Mips::F29},
205 {.CVReg: codeview::RegisterId::MIPS_F30, .Reg: Mips::F30},
206 {.CVReg: codeview::RegisterId::MIPS_F31, .Reg: Mips::F31},
207 {.CVReg: codeview::RegisterId::MIPS_Fsr, .Reg: Mips::FCR31},
208 };
209 for (const auto &I : RegMap)
210 MRI->mapLLVMRegToCVReg(LLVMReg: I.Reg, CVReg: static_cast<int>(I.CVReg));
211}
212
213namespace {
214class MipsWinCOFFTargetStreamer : public MipsTargetStreamer {
215public:
216 MipsWinCOFFTargetStreamer(MCStreamer &S) : MipsTargetStreamer(S) {}
217};
218} // end namespace
219
220/// Select the Mips CPU for the given triple and cpu name.
221StringRef MIPS_MC::selectMipsCPU(const Triple &TT, StringRef CPU) {
222 if (CPU.empty() || CPU == "generic") {
223 if (TT.getSubArch() == llvm::Triple::MipsSubArch_r6) {
224 if (TT.isMIPS32())
225 CPU = "mips32r6";
226 else
227 CPU = "mips64r6";
228 } else {
229 if (TT.isNanoMips())
230 CPU = "nanomips";
231 else if (TT.isMIPS32())
232 CPU = "mips32";
233 else
234 CPU = "mips64";
235 }
236 }
237 return CPU;
238}
239
240static MCInstrInfo *createMipsMCInstrInfo() {
241 MCInstrInfo *X = new MCInstrInfo();
242 InitMipsMCInstrInfo(II: X);
243 return X;
244}
245
246static MCRegisterInfo *createMipsMCRegisterInfo(const Triple &TT) {
247 MCRegisterInfo *X = new MCRegisterInfo();
248 InitMipsMCRegisterInfo(RI: X, RA: Mips::RA);
249 return X;
250}
251
252static MCSubtargetInfo *createMipsMCSubtargetInfo(const Triple &TT,
253 StringRef CPU, StringRef FS) {
254 CPU = MIPS_MC::selectMipsCPU(TT, CPU);
255 return createMipsMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, FS);
256}
257
258static MCAsmInfo *createMipsMCAsmInfo(const MCRegisterInfo &MRI,
259 const Triple &TT,
260 const MCTargetOptions &Options) {
261 MCAsmInfo *MAI;
262
263 if (TT.isOSBinFormatCOFF())
264 MAI = new MipsCOFFMCAsmInfo(Options);
265 else
266 MAI = new MipsELFMCAsmInfo(TT, Options);
267
268 unsigned SP = MRI.getDwarfRegNum(Reg: Mips::SP, isEH: true);
269 MCCFIInstruction Inst = MCCFIInstruction::createDefCfaRegister(L: nullptr, Register: SP);
270 MAI->addInitialFrameState(Inst);
271
272 return MAI;
273}
274
275static MCInstPrinter *createMipsMCInstPrinter(const Triple &T,
276 unsigned SyntaxVariant,
277 const MCAsmInfo &MAI,
278 const MCInstrInfo &MII,
279 const MCRegisterInfo &MRI) {
280 return new MipsInstPrinter(MAI, MII, MRI);
281}
282
283static MCStreamer *createMCStreamer(const Triple &T, MCContext &Context,
284 std::unique_ptr<MCAsmBackend> &&MAB,
285 std::unique_ptr<MCObjectWriter> &&OW,
286 std::unique_ptr<MCCodeEmitter> &&Emitter) {
287 MCStreamer *S;
288 S = createMipsELFStreamer(Context, MAB: std::move(MAB), OW: std::move(OW),
289 Emitter: std::move(Emitter));
290 return S;
291}
292
293static MCTargetStreamer *createMipsAsmTargetStreamer(MCStreamer &S,
294 formatted_raw_ostream &OS,
295 MCInstPrinter *InstPrint) {
296 return new MipsTargetAsmStreamer(S, OS);
297}
298
299static MCTargetStreamer *createMipsNullTargetStreamer(MCStreamer &S) {
300 return new MipsTargetStreamer(S);
301}
302
303static MCTargetStreamer *
304createMipsObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI) {
305 if (STI.getTargetTriple().isOSBinFormatCOFF())
306 return new MipsWinCOFFTargetStreamer(S);
307 return new MipsTargetELFStreamer(S, STI);
308}
309
310namespace {
311
312class MipsMCInstrAnalysis : public MCInstrAnalysis {
313public:
314 MipsMCInstrAnalysis(const MCInstrInfo *Info) : MCInstrAnalysis(Info) {}
315
316 bool evaluateBranch(const MCInst &Inst, uint64_t Addr, uint64_t Size,
317 uint64_t &Target) const override {
318 unsigned NumOps = Inst.getNumOperands();
319 // Register-list transfers have more MC operands than descriptor entries.
320 if (NumOps == 0 || NumOps > Info->get(Opcode: Inst.getOpcode()).getNumOperands())
321 return false;
322 switch (Info->get(Opcode: Inst.getOpcode()).operands()[NumOps - 1].OperandType) {
323 case MipsII::OPERAND_JUMP_TARGET: {
324 // Absolute branch within the current 256 MB-aligned region
325 uint64_t Region = Addr & ~uint64_t(0xfffffff);
326 Target = Region + Inst.getOperand(i: NumOps - 1).getImm();
327 return true;
328 }
329 case MipsII::OPERAND_JUMP_TARGET_MM: {
330 // Absolute branch within the current 128 MB-aligned region
331 uint64_t Region = Addr & ~uint64_t(0x7ffffff);
332 Target = Region + Inst.getOperand(i: NumOps - 1).getImm();
333 return true;
334 }
335 case MCOI::OPERAND_PCREL:
336 // b, beq ...
337 Target = Addr + Inst.getOperand(i: NumOps - 1).getImm();
338 return true;
339 default:
340 return false;
341 }
342 }
343};
344} // anonymous namespace
345
346static MCInstrAnalysis *createMipsMCInstrAnalysis(const MCInstrInfo *Info) {
347 return new MipsMCInstrAnalysis(Info);
348}
349
350extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeMipsTargetMC() {
351 static opt::RegisterLibraryOptions<MipsMCOptions> O;
352 for (Target *T :
353 {&getTheMipsTarget(), &getTheMipselTarget(), &getTheMips64Target(),
354 &getTheMips64elTarget(), &getTheNanoMipsTarget()}) {
355 // Register the MC asm info.
356 RegisterMCAsmInfoFn X(*T, createMipsMCAsmInfo);
357
358 // Register the MC instruction info.
359 TargetRegistry::RegisterMCInstrInfo(T&: *T, Fn: createMipsMCInstrInfo);
360
361 // Register the MC register info.
362 TargetRegistry::RegisterMCRegInfo(T&: *T, Fn: createMipsMCRegisterInfo);
363
364 // Register the elf streamer.
365 TargetRegistry::RegisterELFStreamer(T&: *T, Fn: createMCStreamer);
366
367 // Register the asm target streamer.
368 TargetRegistry::RegisterAsmTargetStreamer(T&: *T, Fn: createMipsAsmTargetStreamer);
369
370 TargetRegistry::RegisterNullTargetStreamer(T&: *T,
371 Fn: createMipsNullTargetStreamer);
372
373 TargetRegistry::RegisterCOFFStreamer(T&: *T, Fn: createMipsWinCOFFStreamer);
374
375 // Register the MC subtarget info.
376 TargetRegistry::RegisterMCSubtargetInfo(T&: *T, Fn: createMipsMCSubtargetInfo);
377
378 // Register the MC instruction analyzer.
379 TargetRegistry::RegisterMCInstrAnalysis(T&: *T, Fn: createMipsMCInstrAnalysis);
380
381 // Register the MCInstPrinter.
382 TargetRegistry::RegisterMCInstPrinter(T&: *T, Fn: createMipsMCInstPrinter);
383
384 TargetRegistry::RegisterObjectTargetStreamer(
385 T&: *T, Fn: createMipsObjectTargetStreamer);
386
387 // Register the asm backend.
388 TargetRegistry::RegisterMCAsmBackend(T&: *T, Fn: createMipsAsmBackend);
389 }
390
391 // Register the MC Code Emitter
392 for (Target *T : {&getTheMipsTarget(), &getTheMips64Target()})
393 TargetRegistry::RegisterMCCodeEmitter(T&: *T, Fn: createMipsMCCodeEmitterEB);
394
395 for (Target *T : {&getTheMipselTarget(), &getTheMips64elTarget(),
396 &getTheNanoMipsTarget()})
397 TargetRegistry::RegisterMCCodeEmitter(T&: *T, Fn: createMipsMCCodeEmitterEL);
398}
399