1//===-- RISCVAsmPrinter.cpp - RISC-V LLVM assembly writer -----------------===//
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 contains a printer that converts from our internal representation
10// of machine-dependent LLVM code to the RISC-V assembly language.
11//
12//===----------------------------------------------------------------------===//
13
14#include "RISCVAsmPrinter.h"
15#include "MCTargetDesc/RISCVBaseInfo.h"
16#include "MCTargetDesc/RISCVELFStreamer.h"
17#include "MCTargetDesc/RISCVInstPrinter.h"
18#include "MCTargetDesc/RISCVMCAsmInfo.h"
19#include "MCTargetDesc/RISCVMatInt.h"
20#include "MCTargetDesc/RISCVTargetStreamer.h"
21#include "RISCV.h"
22#include "RISCVConstantPoolValue.h"
23#include "RISCVMachineFunctionInfo.h"
24#include "RISCVRegisterInfo.h"
25#include "TargetInfo/RISCVTargetInfo.h"
26#include "llvm/ADT/APInt.h"
27#include "llvm/ADT/Statistic.h"
28#include "llvm/BinaryFormat/ELF.h"
29#include "llvm/CodeGen/AsmPrinter.h"
30#include "llvm/CodeGen/AsmPrinterAnalysis.h"
31#include "llvm/CodeGen/MachineConstantPool.h"
32#include "llvm/CodeGen/MachineFunctionAnalysisManager.h"
33#include "llvm/CodeGen/MachineInstr.h"
34#include "llvm/CodeGen/MachineModuleInfo.h"
35#include "llvm/IR/Module.h"
36#include "llvm/MC/MCAsmInfo.h"
37#include "llvm/MC/MCContext.h"
38#include "llvm/MC/MCInst.h"
39#include "llvm/MC/MCInstBuilder.h"
40#include "llvm/MC/MCObjectFileInfo.h"
41#include "llvm/MC/MCSectionELF.h"
42#include "llvm/MC/MCStreamer.h"
43#include "llvm/MC/MCSymbol.h"
44#include "llvm/MC/TargetRegistry.h"
45#include "llvm/Support/CHERICapabilityFormat.h"
46#include "llvm/Support/Compiler.h"
47#include "llvm/Support/raw_ostream.h"
48#include "llvm/TargetParser/RISCVISAInfo.h"
49#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
50
51using namespace llvm;
52
53#define DEBUG_TYPE "asm-printer"
54
55STATISTIC(RISCVNumInstrsCompressed,
56 "Number of RISC-V Compressed instructions emitted");
57
58namespace {
59class RISCVAsmPrinter : public AsmPrinter {
60public:
61 static char ID;
62
63private:
64 const RISCVMCOptions &CLOpts;
65 const RISCVSubtarget *STI;
66
67public:
68 explicit RISCVAsmPrinter(TargetMachine &TM,
69 std::unique_ptr<MCStreamer> Streamer)
70 : AsmPrinter(TM, std::move(Streamer), ID),
71 CLOpts(RISCV_MC::getCLOpts(Options: TM.Options.MCOptions)) {}
72
73 StringRef getPassName() const override { return "RISC-V Assembly Printer"; }
74
75 RISCVTargetStreamer &getTargetStreamer() const {
76 return static_cast<RISCVTargetStreamer &>(
77 *OutStreamer->getTargetStreamer());
78 }
79
80 void LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
81 const MachineInstr &MI);
82
83 void LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
84 const MachineInstr &MI);
85
86 void LowerSTATEPOINT(MCStreamer &OutStreamer, StackMaps &SM,
87 const MachineInstr &MI);
88
89 bool runOnMachineFunction(MachineFunction &MF) override;
90
91 void emitInstruction(const MachineInstr *MI) override;
92
93 void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) override;
94
95 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
96 const char *ExtraCode, raw_ostream &OS) override;
97 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
98 const char *ExtraCode, raw_ostream &OS) override;
99
100 // Returns whether Inst is compressed.
101 bool EmitToStreamer(MCStreamer &S, const MCInst &Inst,
102 const MCSubtargetInfo &SubtargetInfo);
103 bool EmitToStreamer(MCStreamer &S, const MCInst &Inst) {
104 return EmitToStreamer(S, Inst, SubtargetInfo: *STI);
105 }
106
107 bool lowerPseudoInstExpansion(const MachineInstr *MI, MCInst &Inst);
108
109 typedef std::tuple<unsigned, uint32_t> HwasanMemaccessTuple;
110 std::map<HwasanMemaccessTuple, MCSymbol *> HwasanMemaccessSymbols;
111 void LowerHWASAN_CHECK_MEMACCESS(const MachineInstr &MI);
112 void LowerKCFI_CHECK(const MachineInstr &MI);
113 void EmitHwasanMemaccessSymbols(Module &M);
114
115 // Wrapper needed for tblgenned pseudo lowering.
116 bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp) const;
117
118 void emitStartOfAsmFile(Module &M) override;
119 void emitEndOfAsmFile(Module &M) override;
120
121 void emitFunctionEntryLabel() override;
122 bool emitTargetFeaturePush(const MCSubtargetInfo &STI) override;
123 void emitTargetFeaturePop(const MCSubtargetInfo &STI, bool DidPush) override;
124
125 void emitNoteGnuProperty(const Module &M);
126
127private:
128 void emitNTLHint(const MachineInstr *MI);
129
130 void emitLpadAlignedCall(const MachineInstr &MI);
131
132 // XRay Support
133 void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr *MI);
134 void LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr *MI);
135 void LowerPATCHABLE_TAIL_CALL(const MachineInstr *MI);
136 void emitSled(const MachineInstr *MI, SledKind Kind);
137
138 void lowerToMCInst(const MachineInstr *MI, MCInst &OutMI);
139
140 MaybeAlign
141 getRequiredGlobalAlignmentGranule(const GlobalVariable &GV) override;
142};
143} // namespace
144
145void RISCVAsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM,
146 const MachineInstr &MI) {
147 unsigned NOPBytes = STI->hasStdExtZca() ? 2 : 4;
148 unsigned NumNOPBytes = StackMapOpers(&MI).getNumPatchBytes();
149
150 auto &Ctx = OutStreamer.getContext();
151 MCSymbol *MILabel = Ctx.createTempSymbol();
152 OutStreamer.emitLabel(Symbol: MILabel);
153
154 SM.recordStackMap(L: *MILabel, MI);
155 assert(NumNOPBytes % NOPBytes == 0 &&
156 "Invalid number of NOP bytes requested!");
157
158 // Scan ahead to trim the shadow.
159 const MachineBasicBlock &MBB = *MI.getParent();
160 MachineBasicBlock::const_iterator MII(MI);
161 ++MII;
162 while (NumNOPBytes > 0) {
163 if (MII != MBB.end() && MII->isDebugInstr()) {
164 ++MII;
165 continue;
166 }
167 if (MII == MBB.end() || MII->isCall() ||
168 MII->getOpcode() == TargetOpcode::PATCHPOINT ||
169 MII->getOpcode() == TargetOpcode::STACKMAP)
170 break;
171 ++MII;
172 NumNOPBytes -= NOPBytes;
173 }
174
175 // Emit nops.
176 emitNops(N: NumNOPBytes / NOPBytes);
177}
178
179// Lower a patchpoint of the form:
180// [<def>], <id>, <numBytes>, <target>, <numArgs>
181void RISCVAsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM,
182 const MachineInstr &MI) {
183 unsigned NOPBytes = STI->hasStdExtZca() ? 2 : 4;
184
185 auto &Ctx = OutStreamer.getContext();
186 MCSymbol *MILabel = Ctx.createTempSymbol();
187 OutStreamer.emitLabel(Symbol: MILabel);
188 SM.recordPatchPoint(L: *MILabel, MI);
189
190 PatchPointOpers Opers(&MI);
191
192 const MachineOperand &CalleeMO = Opers.getCallTarget();
193 unsigned EncodedBytes = 0;
194
195 if (CalleeMO.isImm()) {
196 uint64_t CallTarget = CalleeMO.getImm();
197 if (CallTarget) {
198 assert((CallTarget & 0xFFFF'FFFF'FFFF) == CallTarget &&
199 "High 16 bits of call target should be zero.");
200 // Materialize the jump address:
201 SmallVector<MCInst, 8> Seq;
202 RISCVMatInt::generateMCInstSeq(Val: CallTarget, STI: *STI, DestReg: RISCV::X1, Insts&: Seq);
203 for (MCInst &Inst : Seq) {
204 bool Compressed = EmitToStreamer(S&: OutStreamer, Inst);
205 EncodedBytes += Compressed ? 2 : 4;
206 }
207 bool Compressed = EmitToStreamer(S&: OutStreamer, Inst: MCInstBuilder(RISCV::JALR)
208 .addReg(Reg: RISCV::X1)
209 .addReg(Reg: RISCV::X1)
210 .addImm(Val: 0));
211 EncodedBytes += Compressed ? 2 : 4;
212 }
213 } else if (CalleeMO.isGlobal()) {
214 MCOperand CallTargetMCOp;
215 lowerOperand(MO: CalleeMO, MCOp&: CallTargetMCOp);
216 EmitToStreamer(S&: OutStreamer,
217 Inst: MCInstBuilder(RISCV::PseudoCALL).addOperand(Op: CallTargetMCOp));
218 EncodedBytes += 8;
219 }
220
221 // Emit padding.
222 unsigned NumBytes = Opers.getNumPatchBytes();
223 assert(NumBytes >= EncodedBytes &&
224 "Patchpoint can't request size less than the length of a call.");
225 assert((NumBytes - EncodedBytes) % NOPBytes == 0 &&
226 "Invalid number of NOP bytes requested!");
227 emitNops(N: (NumBytes - EncodedBytes) / NOPBytes);
228}
229
230void RISCVAsmPrinter::LowerSTATEPOINT(MCStreamer &OutStreamer, StackMaps &SM,
231 const MachineInstr &MI) {
232 unsigned NOPBytes = STI->hasStdExtZca() ? 2 : 4;
233
234 StatepointOpers SOpers(&MI);
235 if (unsigned PatchBytes = SOpers.getNumPatchBytes()) {
236 assert(PatchBytes % NOPBytes == 0 &&
237 "Invalid number of NOP bytes requested!");
238 emitNops(N: PatchBytes / NOPBytes);
239 } else {
240 // Lower call target and choose correct opcode
241 const MachineOperand &CallTarget = SOpers.getCallTarget();
242 MCOperand CallTargetMCOp;
243 switch (CallTarget.getType()) {
244 case MachineOperand::MO_GlobalAddress:
245 case MachineOperand::MO_ExternalSymbol:
246 lowerOperand(MO: CallTarget, MCOp&: CallTargetMCOp);
247 EmitToStreamer(
248 S&: OutStreamer,
249 Inst: MCInstBuilder(RISCV::PseudoCALL).addOperand(Op: CallTargetMCOp));
250 break;
251 case MachineOperand::MO_Immediate:
252 CallTargetMCOp = MCOperand::createImm(Val: CallTarget.getImm());
253 EmitToStreamer(S&: OutStreamer, Inst: MCInstBuilder(RISCV::JAL)
254 .addReg(Reg: RISCV::X1)
255 .addOperand(Op: CallTargetMCOp));
256 break;
257 case MachineOperand::MO_Register:
258 CallTargetMCOp = MCOperand::createReg(Reg: CallTarget.getReg());
259 EmitToStreamer(S&: OutStreamer, Inst: MCInstBuilder(RISCV::JALR)
260 .addReg(Reg: RISCV::X1)
261 .addOperand(Op: CallTargetMCOp)
262 .addImm(Val: 0));
263 break;
264 default:
265 llvm_unreachable("Unsupported operand type in statepoint call target");
266 break;
267 }
268 }
269
270 auto &Ctx = OutStreamer.getContext();
271 MCSymbol *MILabel = Ctx.createTempSymbol();
272 OutStreamer.emitLabel(Symbol: MILabel);
273 SM.recordStatepoint(L: *MILabel, MI);
274}
275
276bool RISCVAsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst,
277 const MCSubtargetInfo &SubtargetInfo) {
278 MCInst CInst;
279 bool Res = RISCVRVC::compress(OutInst&: CInst, MI: Inst, STI: SubtargetInfo);
280 if (Res)
281 ++RISCVNumInstrsCompressed;
282 S.emitInstruction(Inst: Res ? CInst : Inst, STI: SubtargetInfo);
283 return Res;
284}
285
286// Simple pseudo-instructions have their lowering (with expansion to real
287// instructions) auto-generated.
288#include "RISCVGenMCPseudoLowering.inc"
289
290// Emit a call to a returns_twice function with LPAD.
291// When Zca is enabled, emit .p2align 2 before the call to ensure the
292// following LPAD is 4-byte aligned. For assembly output, wrap with
293// .option push/exact/pop to prevent relaxation. For object output,
294// emit the pseudo directly so MCCodeEmitter handles it without R_RISCV_RELAX.
295void RISCVAsmPrinter::emitLpadAlignedCall(const MachineInstr &MI) {
296 const MCSubtargetInfo &MCSTI = getSubtargetInfo();
297 const bool IsIndirect = MI.getOpcode() == RISCV::PseudoCALLIndirectLpadAlign,
298 HasZca = MCSTI.hasFeature(Feature: RISCV::FeatureStdExtZca),
299 HasRelax = MCSTI.hasFeature(Feature: RISCV::FeatureRelax);
300
301 if (HasZca)
302 OutStreamer->emitCodeAlignment(Alignment: Align(4), STI: MCSTI);
303
304 if (OutStreamer->hasRawTextSupport()) {
305 // Assembly path: wrap call with .option push/exact/pop and emit LPAD
306 // separately so the output is human-readable.
307 RISCVTargetStreamer &RTS = getTargetStreamer();
308 if (HasZca && HasRelax) {
309 RTS.emitDirectiveOptionPush();
310 RTS.emitDirectiveOptionExact();
311 }
312
313 MCInst CallInst;
314 if (!IsIndirect) {
315 MCOperand MCOp;
316 lowerOperand(MO: MI.getOperand(i: 0), MCOp);
317 CallInst = MCInstBuilder(RISCV::PseudoCALL).addOperand(Op: MCOp);
318 } else {
319 CallInst = MCInstBuilder(RISCV::JALR)
320 .addReg(Reg: RISCV::X1)
321 .addReg(Reg: MI.getOperand(i: 0).getReg())
322 .addImm(Val: 0);
323 }
324
325 if (HasZca && HasRelax) {
326 MCSubtargetInfo NoRelaxSTI(MCSTI);
327 NoRelaxSTI.ToggleFeature(FB: RISCV::FeatureRelax);
328 EmitToStreamer(S&: *OutStreamer, Inst: CallInst, SubtargetInfo: NoRelaxSTI);
329 RTS.emitDirectiveOptionPop();
330 } else {
331 EmitToStreamer(S&: *OutStreamer, Inst: CallInst, SubtargetInfo: MCSTI);
332 }
333
334 // LPAD is encoded as AUIPC X0, label.
335 MCInst LpadInst = MCInstBuilder(RISCV::AUIPC)
336 .addReg(Reg: RISCV::X0)
337 .addImm(Val: MI.getOperand(i: 1).getImm());
338 EmitToStreamer(S&: *OutStreamer, Inst: LpadInst, SubtargetInfo: MCSTI);
339 } else {
340 // Object path: emit PseudoCALL(Indirect)LpadAlign directly.
341 // MCCodeEmitter::expandFunctionCallLpad expands to AUIPC+JALR+LPAD
342 // without emitting R_RISCV_RELAX on the call fixup.
343 MCInst TmpInst;
344 TmpInst.setOpcode(MI.getOpcode());
345 if (!IsIndirect) {
346 MCOperand MCOp;
347 lowerOperand(MO: MI.getOperand(i: 0), MCOp);
348 TmpInst.addOperand(Op: MCOp);
349 } else {
350 TmpInst.addOperand(Op: MCOperand::createReg(Reg: MI.getOperand(i: 0).getReg()));
351 }
352 TmpInst.addOperand(Op: MCOperand::createImm(Val: MI.getOperand(i: 1).getImm()));
353 EmitToStreamer(S&: *OutStreamer, Inst: TmpInst, SubtargetInfo: MCSTI);
354 }
355}
356
357// If the instruction has a nontemporal MachineMemOperand, emit an NTL hint
358// instruction before it. NTL hints are always safe to emit since they use
359// HINT encodings that are guaranteed not to trap
360// (riscv-non-isa/riscv-elf-psabi-doc#474).
361void RISCVAsmPrinter::emitNTLHint(const MachineInstr *MI) {
362 if (!STI->getInstrInfo()->requiresNTLHint(MI: *MI))
363 return;
364
365 assert(!MI->memoperands_empty());
366
367 MachineMemOperand *MMO = *(MI->memoperands_begin());
368
369 assert(MMO->isNonTemporal());
370
371 unsigned NontemporalMode = 0;
372 if (MMO->getFlags() & MONontemporalBit0)
373 NontemporalMode += 0b1;
374 if (MMO->getFlags() & MONontemporalBit1)
375 NontemporalMode += 0b10;
376
377 MCInst Hint;
378 if (STI->hasStdExtZca())
379 Hint.setOpcode(RISCV::C_ADD);
380 else
381 Hint.setOpcode(RISCV::ADD);
382
383 Hint.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
384 Hint.addOperand(Op: MCOperand::createReg(Reg: RISCV::X0));
385 Hint.addOperand(Op: MCOperand::createReg(Reg: RISCV::X2 + NontemporalMode));
386
387 EmitToStreamer(S&: *OutStreamer, Inst: Hint);
388}
389
390void RISCVAsmPrinter::emitInstruction(const MachineInstr *MI) {
391 RISCV_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(), Features: STI->getFeatureBits());
392
393 emitNTLHint(MI);
394
395 // Do any auto-generated pseudo lowerings.
396 if (MCInst OutInst; lowerPseudoInstExpansion(MI, Inst&: OutInst)) {
397 EmitToStreamer(S&: *OutStreamer, Inst: OutInst);
398 return;
399 }
400
401 switch (MI->getOpcode()) {
402 case RISCV::PseudoTAILX7: {
403 // Lower to PseudoTAILReg with X7 as the register operand.
404 MCOperand SymOp;
405 lowerOperand(MO: MI->getOperand(i: 0), MCOp&: SymOp);
406 MCInst TmpInst;
407 TmpInst.setOpcode(RISCV::PseudoTAILReg);
408 TmpInst.addOperand(Op: MCOperand::createReg(Reg: RISCV::X7));
409 TmpInst.addOperand(Op: SymOp);
410 EmitToStreamer(S&: *OutStreamer, Inst: TmpInst);
411 return;
412 }
413 case RISCV::HWASAN_CHECK_MEMACCESS_SHORTGRANULES:
414 LowerHWASAN_CHECK_MEMACCESS(MI: *MI);
415 return;
416 case RISCV::KCFI_CHECK:
417 LowerKCFI_CHECK(MI: *MI);
418 return;
419 case TargetOpcode::STACKMAP:
420 return LowerSTACKMAP(OutStreamer&: *OutStreamer, SM, MI: *MI);
421 case TargetOpcode::PATCHPOINT:
422 return LowerPATCHPOINT(OutStreamer&: *OutStreamer, SM, MI: *MI);
423 case TargetOpcode::STATEPOINT:
424 return LowerSTATEPOINT(OutStreamer&: *OutStreamer, SM, MI: *MI);
425 case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
426 const Function &F = MI->getParent()->getParent()->getFunction();
427 if (F.hasFnAttribute(Kind: "patchable-function-entry")) {
428 unsigned Num =
429 F.getFnAttributeAsParsedInteger(Kind: "patchable-function-entry");
430 emitNops(N: Num);
431 return;
432 }
433 LowerPATCHABLE_FUNCTION_ENTER(MI);
434 return;
435 }
436 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
437 LowerPATCHABLE_FUNCTION_EXIT(MI);
438 return;
439 case TargetOpcode::PATCHABLE_TAIL_CALL:
440 LowerPATCHABLE_TAIL_CALL(MI);
441 return;
442 case RISCV::PseudoCALLLpadAlign:
443 case RISCV::PseudoCALLIndirectLpadAlign:
444 emitLpadAlignedCall(MI: *MI);
445 return;
446 }
447
448 MCInst OutInst;
449 lowerToMCInst(MI, OutMI&: OutInst);
450 EmitToStreamer(S&: *OutStreamer, Inst: OutInst);
451}
452
453bool RISCVAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
454 const char *ExtraCode, raw_ostream &OS) {
455 // First try the generic code, which knows about modifiers like 'c' and 'n'.
456 if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
457 return false;
458
459 const MachineOperand &MO = MI->getOperand(i: OpNo);
460 if (ExtraCode && ExtraCode[0]) {
461 if (ExtraCode[1] != 0)
462 return true; // Unknown modifier.
463
464 switch (ExtraCode[0]) {
465 default:
466 return true; // Unknown modifier.
467 case 'z': // Print zero register if zero, regular printing otherwise.
468 if (MO.isImm() && MO.getImm() == 0) {
469 OS << RISCVInstPrinter::getRegisterName(CLOpts, Reg: RISCV::X0);
470 return false;
471 }
472 break;
473 case 'i': // Literal 'i' if operand is not a register.
474 if (!MO.isReg())
475 OS << 'i';
476 return false;
477 case 'N': { // Print the register encoding as an integer (0-31)
478 if (!MO.isReg())
479 return true;
480
481 const RISCVRegisterInfo *TRI = STI->getRegisterInfo();
482 OS << TRI->getEncodingValue(Reg: MO.getReg());
483 return false;
484 }
485 }
486 }
487
488 switch (MO.getType()) {
489 case MachineOperand::MO_Immediate:
490 OS << MO.getImm();
491 return false;
492 case MachineOperand::MO_Register:
493 OS << RISCVInstPrinter::getRegisterName(CLOpts, Reg: MO.getReg());
494 return false;
495 case MachineOperand::MO_GlobalAddress:
496 PrintSymbolOperand(MO, OS);
497 return false;
498 case MachineOperand::MO_BlockAddress: {
499 MCSymbol *Sym = GetBlockAddressSymbol(BA: MO.getBlockAddress());
500 Sym->print(OS, MAI);
501 return false;
502 }
503 default:
504 break;
505 }
506
507 return true;
508}
509
510bool RISCVAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
511 unsigned OpNo,
512 const char *ExtraCode,
513 raw_ostream &OS) {
514 if (ExtraCode)
515 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
516
517 const MachineOperand &AddrReg = MI->getOperand(i: OpNo);
518 assert(MI->getNumOperands() > OpNo + 1 && "Expected additional operand");
519 const MachineOperand &Offset = MI->getOperand(i: OpNo + 1);
520 // All memory operands should have a register and an immediate operand (see
521 // RISCVDAGToDAGISel::SelectInlineAsmMemoryOperand).
522 if (!AddrReg.isReg())
523 return true;
524 if (!Offset.isImm() && !Offset.isGlobal() && !Offset.isBlockAddress() &&
525 !Offset.isMCSymbol())
526 return true;
527
528 MCOperand MCO;
529 if (!lowerOperand(MO: Offset, MCOp&: MCO))
530 return true;
531
532 if (Offset.isImm())
533 OS << MCO.getImm();
534 else if (Offset.isGlobal() || Offset.isBlockAddress() || Offset.isMCSymbol())
535 MAI.printExpr(OS, *MCO.getExpr());
536
537 if (Offset.isMCSymbol())
538 MMI->getContext().registerInlineAsmLabel(Sym: Offset.getMCSymbol());
539 if (Offset.isBlockAddress()) {
540 const BlockAddress *BA = Offset.getBlockAddress();
541 MCSymbol *Sym = GetBlockAddressSymbol(BA);
542 MMI->getContext().registerInlineAsmLabel(Sym);
543 }
544
545 OS << "(" << RISCVInstPrinter::getRegisterName(CLOpts, Reg: AddrReg.getReg())
546 << ")";
547 return false;
548}
549
550bool RISCVAsmPrinter::emitTargetFeaturePush(const MCSubtargetInfo &STI) {
551 RISCVTargetStreamer &RTS = getTargetStreamer();
552 SmallVector<RISCVOptionArchArg> NeedEmitStdOptionArgs;
553 const MCSubtargetInfo &MCSTI = TM.getMCSubtargetInfo();
554 for (const auto &Feature : MCSTI.getAllProcessorFeatures()) {
555 if (STI.hasFeature(Feature: Feature.Value) == MCSTI.hasFeature(Feature: Feature.Value))
556 continue;
557
558 if (!llvm::RISCVISAInfo::isSupportedExtensionFeature(Ext: Feature.key()))
559 continue;
560
561 auto Delta = STI.hasFeature(Feature: Feature.Value) ? RISCVOptionArchArgType::Plus
562 : RISCVOptionArchArgType::Minus;
563 StringRef ExtName = Feature.key();
564 ExtName.consume_front(Prefix: "experimental-");
565 NeedEmitStdOptionArgs.emplace_back(Args&: Delta, Args: ExtName.str());
566 }
567 if (!NeedEmitStdOptionArgs.empty()) {
568 RTS.emitDirectiveOptionPush();
569 RTS.emitDirectiveOptionArch(Args: NeedEmitStdOptionArgs);
570 RTS.setArchString(
571 cantFail(ValOrErr: RISCVFeatures::parseFeatureBits(STI))->toString());
572 return true;
573 }
574
575 return false;
576}
577
578void RISCVAsmPrinter::emitTargetFeaturePop(const MCSubtargetInfo &STI,
579 bool DidPush) {
580 if (DidPush)
581 getTargetStreamer().emitDirectiveOptionPop();
582}
583
584bool RISCVAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
585 STI = &MF.getSubtarget<RISCVSubtarget>();
586
587 bool EmittedOptionArch = emitTargetFeaturePush(STI: *STI);
588
589 SetupMachineFunction(MF);
590 emitFunctionBody();
591
592 // Emit the XRay table
593 emitXRayTable();
594
595 emitTargetFeaturePop(STI: *STI, DidPush: EmittedOptionArch);
596 return false;
597}
598
599void RISCVAsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr *MI) {
600 emitSled(MI, Kind: SledKind::FUNCTION_ENTER);
601}
602
603void RISCVAsmPrinter::LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr *MI) {
604 emitSled(MI, Kind: SledKind::FUNCTION_EXIT);
605}
606
607void RISCVAsmPrinter::LowerPATCHABLE_TAIL_CALL(const MachineInstr *MI) {
608 emitSled(MI, Kind: SledKind::TAIL_CALL);
609}
610
611void RISCVAsmPrinter::emitSled(const MachineInstr *MI, SledKind Kind) {
612 // We want to emit the jump instruction and the nops constituting the sled.
613 // The format is as follows:
614 // .Lxray_sled_N
615 // ALIGN
616 // J .tmpN
617 // 21 or 33 C.NOP instructions
618 // .tmpN
619
620 // The following variable holds the count of the number of NOPs to be patched
621 // in for XRay instrumentation during compilation.
622 // Note that RV64 and RV32 each has a sled of 68 and 44 bytes, respectively.
623 // Assuming we're using JAL to jump to .tmpN, then we only need
624 // (68 - 4)/2 = 32 NOPs for RV64 and (44 - 4)/2 = 20 for RV32. However, there
625 // is a chance that we'll use C.JAL instead, so an additional NOP is needed.
626 const uint8_t NoopsInSledCount = STI->is64Bit() ? 33 : 21;
627
628 OutStreamer->emitCodeAlignment(Alignment: Align(4), STI: *STI);
629 auto CurSled = OutContext.createTempSymbol(Name: "xray_sled_", AlwaysAddSuffix: true);
630 OutStreamer->emitLabel(Symbol: CurSled);
631 auto Target = OutContext.createTempSymbol();
632
633 const MCExpr *TargetExpr = MCSymbolRefExpr::create(Symbol: Target, Ctx&: OutContext);
634
635 // Emit "J bytes" instruction, which jumps over the nop sled to the actual
636 // start of function.
637 EmitToStreamer(
638 S&: *OutStreamer,
639 Inst: MCInstBuilder(RISCV::JAL).addReg(Reg: RISCV::X0).addExpr(Val: TargetExpr));
640
641 // Emit NOP instructions
642 for (int8_t I = 0; I < NoopsInSledCount; ++I)
643 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::ADDI)
644 .addReg(Reg: RISCV::X0)
645 .addReg(Reg: RISCV::X0)
646 .addImm(Val: 0));
647
648 OutStreamer->emitLabel(Symbol: Target);
649 recordSled(Sled: CurSled, MI: *MI, Kind, Version: 2);
650}
651
652void RISCVAsmPrinter::emitStartOfAsmFile(Module &M) {
653 assert(OutStreamer->getTargetStreamer() &&
654 "target streamer is uninitialized");
655 RISCVTargetStreamer &RTS = getTargetStreamer();
656 StringRef ABIName = M.getTargetABIFromMD();
657 if (!ABIName.empty()) {
658 RISCVABI::ABI ABI = RISCVABI::getTargetABI(ABIName);
659 if (ABI == RISCVABI::ABI::Unknown) {
660 M.getContext().emitError(ErrorStr: Twine('\'') + ABIName +
661 "' is not a recognized ABI for this target");
662 } else {
663 RTS.setTargetABI(ABI);
664 }
665 } else if (!RTS.hasTargetABI()) {
666 RTS.setTargetABI(
667 cantFail(ValOrErr: RISCVABI::computeTargetABI(STI: TM.getMCSubtargetInfo(), ABIName: "")));
668 }
669
670 MCSubtargetInfo SubtargetInfo = TM.getMCSubtargetInfo();
671
672 // Use module flag to update feature bits.
673 if (auto *MD = dyn_cast_or_null<MDNode>(Val: M.getModuleFlag(Key: "riscv-isa"))) {
674 for (auto &ISA : MD->operands()) {
675 if (auto *ISAString = dyn_cast_or_null<MDString>(Val: ISA)) {
676 auto ParseResult = llvm::RISCVISAInfo::parseArchString(
677 Arch: ISAString->getString(), /*EnableExperimentalExtension=*/true,
678 /*ExperimentalExtensionVersionCheck=*/true);
679 if (!errorToBool(Err: ParseResult.takeError())) {
680 auto &ISAInfo = *ParseResult;
681 for (const auto &Feature : SubtargetInfo.getAllProcessorFeatures()) {
682 if (ISAInfo->hasExtension(Ext: Feature.key()) &&
683 !SubtargetInfo.hasFeature(Feature: Feature.Value))
684 SubtargetInfo.ToggleFeature(FS: Feature.key());
685 }
686 }
687 }
688 }
689
690 RTS.setFlagsFromFeatures(SubtargetInfo);
691 }
692
693 if (M.getTargetTriple().isOSBinFormatELF())
694 RTS.emitTargetAttributes(STI: SubtargetInfo, /*EmitStackAlign=*/true);
695}
696
697void RISCVAsmPrinter::emitEndOfAsmFile(Module &M) {
698 RISCVTargetStreamer &RTS = getTargetStreamer();
699
700 if (M.getTargetTriple().isOSBinFormatELF()) {
701 RTS.finishAttributeSection();
702 emitNoteGnuProperty(M);
703 }
704 EmitHwasanMemaccessSymbols(M);
705}
706
707void RISCVAsmPrinter::emitFunctionEntryLabel() {
708 const auto *RMFI = MF->getInfo<RISCVMachineFunctionInfo>();
709 if (RMFI->isVectorCall()) {
710 RISCVTargetStreamer &RTS = getTargetStreamer();
711 RTS.emitDirectiveVariantCC(Symbol&: *CurrentFnSym);
712 }
713 return AsmPrinter::emitFunctionEntryLabel();
714}
715
716// Force static initialization.
717extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
718LLVMInitializeRISCVAsmPrinter() {
719 RegisterAsmPrinter<RISCVAsmPrinter> X(getTheRISCV32Target());
720 RegisterAsmPrinter<RISCVAsmPrinter> Y(getTheRISCV64Target());
721 RegisterAsmPrinter<RISCVAsmPrinter> A(getTheRISCV32beTarget());
722 RegisterAsmPrinter<RISCVAsmPrinter> B(getTheRISCV64beTarget());
723}
724
725void RISCVAsmPrinter::LowerHWASAN_CHECK_MEMACCESS(const MachineInstr &MI) {
726 Register Reg = MI.getOperand(i: 0).getReg();
727 uint32_t AccessInfo = MI.getOperand(i: 1).getImm();
728 MCSymbol *&Sym =
729 HwasanMemaccessSymbols[HwasanMemaccessTuple(Reg, AccessInfo)];
730 if (!Sym) {
731 // FIXME: Make this work on non-ELF.
732 if (!TM.getTargetTriple().isOSBinFormatELF())
733 report_fatal_error(reason: "llvm.hwasan.check.memaccess only supported on ELF");
734
735 std::string SymName = "__hwasan_check_x" + utostr(X: Reg - RISCV::X0) + "_" +
736 utostr(X: AccessInfo) + "_short";
737 Sym = OutContext.getOrCreateSymbol(Name: SymName);
738 }
739 auto Res = MCSymbolRefExpr::create(Symbol: Sym, Ctx&: OutContext);
740 auto Expr = MCSpecifierExpr::create(Expr: Res, S: RISCV::S_CALL_PLT, Ctx&: OutContext);
741
742 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::PseudoCALL).addExpr(Val: Expr));
743}
744
745void RISCVAsmPrinter::LowerKCFI_CHECK(const MachineInstr &MI) {
746 Register AddrReg = MI.getOperand(i: 0).getReg();
747 assert(std::next(MI.getIterator())->isCall() &&
748 "KCFI_CHECK not followed by a call instruction");
749 assert(std::next(MI.getIterator())->getOperand(0).getReg() == AddrReg &&
750 "KCFI_CHECK call target doesn't match call operand");
751
752 // Temporary registers for comparing the hashes. If a register is used
753 // for the call target, or reserved by the user, we can clobber another
754 // temporary register as the check is immediately followed by the
755 // call. The check defaults to X6/X7, but can fall back to X28-X31 if
756 // needed.
757 unsigned ScratchRegs[] = {RISCV::X6, RISCV::X7};
758 unsigned NextReg = RISCV::X28;
759 auto isRegAvailable = [&](unsigned Reg) {
760 return Reg != AddrReg && !STI->isRegisterReservedByUser(i: Reg);
761 };
762 for (auto &Reg : ScratchRegs) {
763 if (isRegAvailable(Reg))
764 continue;
765 while (NextReg <= RISCV::X31 && !isRegAvailable(NextReg))
766 ++NextReg;
767 Reg = NextReg++;
768 if (Reg > RISCV::X31)
769 report_fatal_error(reason: "Unable to find scratch registers for KCFI_CHECK");
770 }
771
772 if (AddrReg == RISCV::X0) {
773 // Checking X0 makes no sense. Instead of emitting a load, zero
774 // ScratchRegs[0].
775 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::ADDI)
776 .addReg(Reg: ScratchRegs[0])
777 .addReg(Reg: RISCV::X0)
778 .addImm(Val: 0));
779 } else {
780 // Adjust the offset for patchable-function-prefix. This assumes that
781 // patchable-function-prefix is the same for all functions.
782 int NopSize = STI->hasStdExtZca() ? 2 : 4;
783 int64_t PrefixNops =
784 MI.getMF()->getFunction().getFnAttributeAsParsedInteger(
785 Kind: "patchable-function-prefix");
786
787 // Load the target function type hash.
788 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::LW)
789 .addReg(Reg: ScratchRegs[0])
790 .addReg(Reg: AddrReg)
791 .addImm(Val: -(PrefixNops * NopSize + 4)));
792 }
793
794 // Load the expected 32-bit type hash.
795 const int64_t Type = MI.getOperand(i: 1).getImm();
796 const int64_t Hi20 = ((Type + 0x800) >> 12) & 0xFFFFF;
797 const int64_t Lo12 = SignExtend64<12>(x: Type);
798 if (Hi20) {
799 EmitToStreamer(
800 S&: *OutStreamer,
801 Inst: MCInstBuilder(RISCV::LUI).addReg(Reg: ScratchRegs[1]).addImm(Val: Hi20));
802 }
803 if (Lo12 || Hi20 == 0) {
804 EmitToStreamer(S&: *OutStreamer,
805 Inst: MCInstBuilder((STI->hasFeature(Feature: RISCV::Feature64Bit) && Hi20)
806 ? RISCV::ADDIW
807 : RISCV::ADDI)
808 .addReg(Reg: ScratchRegs[1])
809 .addReg(Reg: ScratchRegs[1])
810 .addImm(Val: Lo12));
811 }
812
813 // Compare the hashes and trap if there's a mismatch.
814 MCSymbol *Pass = OutContext.createTempSymbol();
815 EmitToStreamer(S&: *OutStreamer,
816 Inst: MCInstBuilder(RISCV::BEQ)
817 .addReg(Reg: ScratchRegs[0])
818 .addReg(Reg: ScratchRegs[1])
819 .addExpr(Val: MCSymbolRefExpr::create(Symbol: Pass, Ctx&: OutContext)));
820
821 MCSymbol *Trap = OutContext.createTempSymbol();
822 OutStreamer->emitLabel(Symbol: Trap);
823 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::EBREAK));
824 emitKCFITrapEntry(MF: *MI.getMF(), Symbol: Trap);
825 OutStreamer->emitLabel(Symbol: Pass);
826}
827
828void RISCVAsmPrinter::EmitHwasanMemaccessSymbols(Module &M) {
829 if (HwasanMemaccessSymbols.empty())
830 return;
831
832 assert(M.getTargetTriple().isOSBinFormatELF());
833 // Use MCSubtargetInfo from TargetMachine. Individual functions may have
834 // attributes that differ from other functions in the module and we have no
835 // way to know which function is correct.
836 const MCSubtargetInfo &MCSTI = TM.getMCSubtargetInfo();
837
838 MCSymbol *HwasanTagMismatchV2Sym =
839 OutContext.getOrCreateSymbol(Name: "__hwasan_tag_mismatch_v2");
840 // Annotate symbol as one having incompatible calling convention, so
841 // run-time linkers can instead eagerly bind this function.
842 RISCVTargetStreamer &RTS = getTargetStreamer();
843 RTS.emitDirectiveVariantCC(Symbol&: *HwasanTagMismatchV2Sym);
844
845 const MCSymbolRefExpr *HwasanTagMismatchV2Ref =
846 MCSymbolRefExpr::create(Symbol: HwasanTagMismatchV2Sym, Ctx&: OutContext);
847 auto Expr = MCSpecifierExpr::create(Expr: HwasanTagMismatchV2Ref, S: RISCV::S_CALL_PLT,
848 Ctx&: OutContext);
849
850 for (auto &P : HwasanMemaccessSymbols) {
851 unsigned Reg = std::get<0>(t: P.first);
852 uint32_t AccessInfo = std::get<1>(t: P.first);
853 MCSymbol *Sym = P.second;
854
855 unsigned Size =
856 1 << ((AccessInfo >> HWASanAccessInfo::AccessSizeShift) & 0xf);
857 OutStreamer->switchSection(Section: OutContext.getELFSection(
858 Section: ".text.hot", Type: ELF::SHT_PROGBITS,
859 Flags: ELF::SHF_EXECINSTR | ELF::SHF_ALLOC | ELF::SHF_GROUP, EntrySize: 0, Group: Sym->getName(),
860 /*IsComdat=*/true));
861
862 OutStreamer->emitSymbolAttribute(Symbol: Sym, Attribute: MCSA_ELF_TypeFunction);
863 OutStreamer->emitSymbolAttribute(Symbol: Sym, Attribute: MCSA_Weak);
864 OutStreamer->emitSymbolAttribute(Symbol: Sym, Attribute: MCSA_Hidden);
865 OutStreamer->emitLabel(Symbol: Sym);
866
867 // Extract shadow offset from ptr
868 EmitToStreamer(
869 S&: *OutStreamer,
870 Inst: MCInstBuilder(RISCV::SLLI).addReg(Reg: RISCV::X6).addReg(Reg).addImm(Val: 8),
871 SubtargetInfo: MCSTI);
872 EmitToStreamer(S&: *OutStreamer,
873 Inst: MCInstBuilder(RISCV::SRLI)
874 .addReg(Reg: RISCV::X6)
875 .addReg(Reg: RISCV::X6)
876 .addImm(Val: 12),
877 SubtargetInfo: MCSTI);
878 // load shadow tag in X6, X5 contains shadow base
879 EmitToStreamer(S&: *OutStreamer,
880 Inst: MCInstBuilder(RISCV::ADD)
881 .addReg(Reg: RISCV::X6)
882 .addReg(Reg: RISCV::X5)
883 .addReg(Reg: RISCV::X6),
884 SubtargetInfo: MCSTI);
885 EmitToStreamer(
886 S&: *OutStreamer,
887 Inst: MCInstBuilder(RISCV::LBU).addReg(Reg: RISCV::X6).addReg(Reg: RISCV::X6).addImm(Val: 0),
888 SubtargetInfo: MCSTI);
889 // Extract tag from pointer and compare it with loaded tag from shadow
890 EmitToStreamer(
891 S&: *OutStreamer,
892 Inst: MCInstBuilder(RISCV::SRLI).addReg(Reg: RISCV::X7).addReg(Reg).addImm(Val: 56),
893 SubtargetInfo: MCSTI);
894 MCSymbol *HandleMismatchOrPartialSym = OutContext.createTempSymbol();
895 // X7 contains tag from the pointer, while X6 contains tag from memory
896 EmitToStreamer(S&: *OutStreamer,
897 Inst: MCInstBuilder(RISCV::BNE)
898 .addReg(Reg: RISCV::X7)
899 .addReg(Reg: RISCV::X6)
900 .addExpr(Val: MCSymbolRefExpr::create(
901 Symbol: HandleMismatchOrPartialSym, Ctx&: OutContext)),
902 SubtargetInfo: MCSTI);
903 MCSymbol *ReturnSym = OutContext.createTempSymbol();
904 OutStreamer->emitLabel(Symbol: ReturnSym);
905 EmitToStreamer(S&: *OutStreamer,
906 Inst: MCInstBuilder(RISCV::JALR)
907 .addReg(Reg: RISCV::X0)
908 .addReg(Reg: RISCV::X1)
909 .addImm(Val: 0),
910 SubtargetInfo: MCSTI);
911 OutStreamer->emitLabel(Symbol: HandleMismatchOrPartialSym);
912
913 EmitToStreamer(S&: *OutStreamer,
914 Inst: MCInstBuilder(RISCV::ADDI)
915 .addReg(Reg: RISCV::X28)
916 .addReg(Reg: RISCV::X0)
917 .addImm(Val: 16),
918 SubtargetInfo: MCSTI);
919 MCSymbol *HandleMismatchSym = OutContext.createTempSymbol();
920 EmitToStreamer(
921 S&: *OutStreamer,
922 Inst: MCInstBuilder(RISCV::BGEU)
923 .addReg(Reg: RISCV::X6)
924 .addReg(Reg: RISCV::X28)
925 .addExpr(Val: MCSymbolRefExpr::create(Symbol: HandleMismatchSym, Ctx&: OutContext)),
926 SubtargetInfo: MCSTI);
927
928 EmitToStreamer(
929 S&: *OutStreamer,
930 Inst: MCInstBuilder(RISCV::ANDI).addReg(Reg: RISCV::X28).addReg(Reg).addImm(Val: 0xF),
931 SubtargetInfo: MCSTI);
932
933 if (Size != 1)
934 EmitToStreamer(S&: *OutStreamer,
935 Inst: MCInstBuilder(RISCV::ADDI)
936 .addReg(Reg: RISCV::X28)
937 .addReg(Reg: RISCV::X28)
938 .addImm(Val: Size - 1),
939 SubtargetInfo: MCSTI);
940 EmitToStreamer(
941 S&: *OutStreamer,
942 Inst: MCInstBuilder(RISCV::BGE)
943 .addReg(Reg: RISCV::X28)
944 .addReg(Reg: RISCV::X6)
945 .addExpr(Val: MCSymbolRefExpr::create(Symbol: HandleMismatchSym, Ctx&: OutContext)),
946 SubtargetInfo: MCSTI);
947
948 EmitToStreamer(
949 S&: *OutStreamer,
950 Inst: MCInstBuilder(RISCV::ORI).addReg(Reg: RISCV::X6).addReg(Reg).addImm(Val: 0xF),
951 SubtargetInfo: MCSTI);
952 EmitToStreamer(
953 S&: *OutStreamer,
954 Inst: MCInstBuilder(RISCV::LBU).addReg(Reg: RISCV::X6).addReg(Reg: RISCV::X6).addImm(Val: 0),
955 SubtargetInfo: MCSTI);
956 EmitToStreamer(S&: *OutStreamer,
957 Inst: MCInstBuilder(RISCV::BEQ)
958 .addReg(Reg: RISCV::X6)
959 .addReg(Reg: RISCV::X7)
960 .addExpr(Val: MCSymbolRefExpr::create(Symbol: ReturnSym, Ctx&: OutContext)),
961 SubtargetInfo: MCSTI);
962
963 OutStreamer->emitLabel(Symbol: HandleMismatchSym);
964
965 // | Previous stack frames... |
966 // +=================================+ <-- [SP + 256]
967 // | ... |
968 // | |
969 // | Stack frame space for x12 - x31.|
970 // | |
971 // | ... |
972 // +---------------------------------+ <-- [SP + 96]
973 // | Saved x11(arg1), as |
974 // | __hwasan_check_* clobbers it. |
975 // +---------------------------------+ <-- [SP + 88]
976 // | Saved x10(arg0), as |
977 // | __hwasan_check_* clobbers it. |
978 // +---------------------------------+ <-- [SP + 80]
979 // | |
980 // | Stack frame space for x9. |
981 // +---------------------------------+ <-- [SP + 72]
982 // | |
983 // | Saved x8(fp), as |
984 // | __hwasan_check_* clobbers it. |
985 // +---------------------------------+ <-- [SP + 64]
986 // | ... |
987 // | |
988 // | Stack frame space for x2 - x7. |
989 // | |
990 // | ... |
991 // +---------------------------------+ <-- [SP + 16]
992 // | Return address (x1) for caller |
993 // | of __hwasan_check_*. |
994 // +---------------------------------+ <-- [SP + 8]
995 // | Reserved place for x0, possibly |
996 // | junk, since we don't save it. |
997 // +---------------------------------+ <-- [x2 / SP]
998
999 // Adjust sp
1000 EmitToStreamer(S&: *OutStreamer,
1001 Inst: MCInstBuilder(RISCV::ADDI)
1002 .addReg(Reg: RISCV::X2)
1003 .addReg(Reg: RISCV::X2)
1004 .addImm(Val: -256),
1005 SubtargetInfo: MCSTI);
1006
1007 // store x10(arg0) by new sp
1008 EmitToStreamer(S&: *OutStreamer,
1009 Inst: MCInstBuilder(RISCV::SD)
1010 .addReg(Reg: RISCV::X10)
1011 .addReg(Reg: RISCV::X2)
1012 .addImm(Val: 8 * 10),
1013 SubtargetInfo: MCSTI);
1014 // store x11(arg1) by new sp
1015 EmitToStreamer(S&: *OutStreamer,
1016 Inst: MCInstBuilder(RISCV::SD)
1017 .addReg(Reg: RISCV::X11)
1018 .addReg(Reg: RISCV::X2)
1019 .addImm(Val: 8 * 11),
1020 SubtargetInfo: MCSTI);
1021
1022 // store x8(fp) by new sp
1023 EmitToStreamer(
1024 S&: *OutStreamer,
1025 Inst: MCInstBuilder(RISCV::SD).addReg(Reg: RISCV::X8).addReg(Reg: RISCV::X2).addImm(Val: 8 *
1026 8),
1027 SubtargetInfo: MCSTI);
1028 // store x1(ra) by new sp
1029 EmitToStreamer(
1030 S&: *OutStreamer,
1031 Inst: MCInstBuilder(RISCV::SD).addReg(Reg: RISCV::X1).addReg(Reg: RISCV::X2).addImm(Val: 1 *
1032 8),
1033 SubtargetInfo: MCSTI);
1034 if (Reg != RISCV::X10)
1035 EmitToStreamer(
1036 S&: *OutStreamer,
1037 Inst: MCInstBuilder(RISCV::ADDI).addReg(Reg: RISCV::X10).addReg(Reg).addImm(Val: 0),
1038 SubtargetInfo: MCSTI);
1039 EmitToStreamer(S&: *OutStreamer,
1040 Inst: MCInstBuilder(RISCV::ADDI)
1041 .addReg(Reg: RISCV::X11)
1042 .addReg(Reg: RISCV::X0)
1043 .addImm(Val: AccessInfo & HWASanAccessInfo::RuntimeMask),
1044 SubtargetInfo: MCSTI);
1045
1046 EmitToStreamer(S&: *OutStreamer, Inst: MCInstBuilder(RISCV::PseudoCALL).addExpr(Val: Expr),
1047 SubtargetInfo: MCSTI);
1048 }
1049}
1050
1051void RISCVAsmPrinter::emitNoteGnuProperty(const Module &M) {
1052 assert(M.getTargetTriple().isOSBinFormatELF() && "invalid binary format");
1053 uint32_t GnuProps = 0;
1054 if (const Metadata *const Flag = M.getModuleFlag(Key: "cf-protection-return");
1055 Flag && !mdconst::extract<ConstantInt>(MD: Flag)->isZero())
1056 GnuProps |= ELF::GNU_PROPERTY_RISCV_FEATURE_1_CFI_SS;
1057
1058 if (const Metadata *const Flag = M.getModuleFlag(Key: "cf-protection-branch");
1059 Flag && !mdconst::extract<ConstantInt>(MD: Flag)->isZero()) {
1060 using namespace llvm::RISCVISAUtils;
1061 const Metadata *const CFBranchLabelSchemeFlag =
1062 M.getModuleFlag(Key: "cf-branch-label-scheme");
1063 assert(CFBranchLabelSchemeFlag &&
1064 "cf-protection=branch should come with cf-branch-label-scheme=... "
1065 "on RISC-V targets");
1066 const StringRef CFBranchLabelScheme =
1067 cast<MDString>(Val: CFBranchLabelSchemeFlag)->getString();
1068 switch (llvm::RISCVCFI::getZicfilpLabelScheme(CFBranchLabelScheme)) {
1069 case llvm::RISCVCFI::ZicfilpLabelSchemeKind::Invalid:
1070 reportFatalInternalError(reason: "invalid RISC-V Zicfilp label scheme");
1071 case llvm::RISCVCFI::ZicfilpLabelSchemeKind::Unlabeled:
1072 GnuProps |= ELF::GNU_PROPERTY_RISCV_FEATURE_1_CFI_LP_UNLABELED;
1073 break;
1074 case llvm::RISCVCFI::ZicfilpLabelSchemeKind::FuncSig:
1075 // TODO: Emit the func-sig bit after the feature is implemented
1076 reportFatalUsageError(reason: "the complete func-sig label scheme feature is not "
1077 "implemented yet");
1078 break;
1079 }
1080 }
1081
1082 if (!GnuProps)
1083 return;
1084
1085 auto &RTS = static_cast<RISCVTargetELFStreamer &>(getTargetStreamer());
1086 RTS.emitNoteGnuPropertySection(Feature1And: GnuProps);
1087}
1088
1089static MCOperand lowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym,
1090 const AsmPrinter &AP) {
1091 MCContext &Ctx = AP.OutContext;
1092 RISCV::Specifier Kind;
1093
1094 switch (MO.getTargetFlags()) {
1095 default:
1096 llvm_unreachable("Unknown target flag on GV operand");
1097 case RISCVII::MO_None:
1098 Kind = RISCV::S_None;
1099 break;
1100 case RISCVII::MO_CALL:
1101 Kind = RISCV::S_CALL_PLT;
1102 break;
1103 case RISCVII::MO_LO:
1104 Kind = RISCV::S_LO;
1105 break;
1106 case RISCVII::MO_HI:
1107 Kind = ELF::R_RISCV_HI20;
1108 break;
1109 case RISCVII::MO_PCREL_LO:
1110 Kind = RISCV::S_PCREL_LO;
1111 break;
1112 case RISCVII::MO_PCREL_HI:
1113 Kind = RISCV::S_PCREL_HI;
1114 break;
1115 case RISCVII::MO_GOT_HI:
1116 Kind = RISCV::S_GOT_HI;
1117 break;
1118 case RISCVII::MO_TPREL_LO:
1119 Kind = RISCV::S_TPREL_LO;
1120 break;
1121 case RISCVII::MO_TPREL_HI:
1122 Kind = ELF::R_RISCV_TPREL_HI20;
1123 break;
1124 case RISCVII::MO_TPREL_ADD:
1125 Kind = ELF::R_RISCV_TPREL_ADD;
1126 break;
1127 case RISCVII::MO_TLS_GOT_HI:
1128 Kind = ELF::R_RISCV_TLS_GOT_HI20;
1129 break;
1130 case RISCVII::MO_TLS_GD_HI:
1131 Kind = ELF::R_RISCV_TLS_GD_HI20;
1132 break;
1133 case RISCVII::MO_TLSDESC_HI:
1134 Kind = ELF::R_RISCV_TLSDESC_HI20;
1135 break;
1136 case RISCVII::MO_TLSDESC_LOAD_LO:
1137 Kind = ELF::R_RISCV_TLSDESC_LOAD_LO12;
1138 break;
1139 case RISCVII::MO_TLSDESC_ADD_LO:
1140 Kind = ELF::R_RISCV_TLSDESC_ADD_LO12;
1141 break;
1142 case RISCVII::MO_TLSDESC_CALL:
1143 Kind = ELF::R_RISCV_TLSDESC_CALL;
1144 break;
1145 case RISCVII::MO_QC_ACCESS:
1146 Kind = RISCV::S_QC_ACCESS;
1147 break;
1148 }
1149
1150 const MCExpr *ME = MCSymbolRefExpr::create(Symbol: Sym, Ctx);
1151
1152 if (!MO.isJTI() && !MO.isMBB() && MO.getOffset())
1153 ME = MCBinaryExpr::createAdd(
1154 LHS: ME, RHS: MCConstantExpr::create(Value: MO.getOffset(), Ctx), Ctx);
1155
1156 if (Kind != RISCV::S_None)
1157 ME = MCSpecifierExpr::create(Expr: ME, S: Kind, Ctx);
1158 return MCOperand::createExpr(Val: ME);
1159}
1160
1161bool RISCVAsmPrinter::lowerOperand(const MachineOperand &MO,
1162 MCOperand &MCOp) const {
1163 switch (MO.getType()) {
1164 default:
1165 report_fatal_error(reason: "lowerOperand: unknown operand type");
1166 case MachineOperand::MO_Register:
1167 // Ignore all implicit register operands.
1168 if (MO.isImplicit())
1169 return false;
1170 MCOp = MCOperand::createReg(Reg: MO.getReg());
1171 break;
1172 case MachineOperand::MO_RegisterMask:
1173 // Regmasks are like implicit defs.
1174 return false;
1175 case MachineOperand::MO_Immediate:
1176 MCOp = MCOperand::createImm(Val: MO.getImm());
1177 break;
1178 case MachineOperand::MO_MachineBasicBlock:
1179 MCOp = lowerSymbolOperand(MO, Sym: MO.getMBB()->getSymbol(), AP: *this);
1180 break;
1181 case MachineOperand::MO_GlobalAddress:
1182 MCOp = lowerSymbolOperand(MO, Sym: getSymbolPreferLocal(GV: *MO.getGlobal()), AP: *this);
1183 break;
1184 case MachineOperand::MO_BlockAddress:
1185 MCOp = lowerSymbolOperand(MO, Sym: GetBlockAddressSymbol(BA: MO.getBlockAddress()),
1186 AP: *this);
1187 break;
1188 case MachineOperand::MO_ExternalSymbol:
1189 MCOp = lowerSymbolOperand(MO, Sym: GetExternalSymbolSymbol(Sym: MO.getSymbolName()),
1190 AP: *this);
1191 break;
1192 case MachineOperand::MO_ConstantPoolIndex:
1193 MCOp = lowerSymbolOperand(MO, Sym: GetCPISymbol(CPID: MO.getIndex()), AP: *this);
1194 break;
1195 case MachineOperand::MO_JumpTableIndex:
1196 MCOp = lowerSymbolOperand(MO, Sym: GetJTISymbol(JTID: MO.getIndex()), AP: *this);
1197 break;
1198 case MachineOperand::MO_MCSymbol:
1199 MCOp = lowerSymbolOperand(MO, Sym: MO.getMCSymbol(), AP: *this);
1200 break;
1201 }
1202 return true;
1203}
1204
1205static bool lowerRISCVVMachineInstrToMCInst(const MachineInstr *MI,
1206 MCInst &OutMI,
1207 const RISCVSubtarget *STI) {
1208 const RISCVVPseudosTable::PseudoInfo *RVV =
1209 RISCVVPseudosTable::getPseudoInfo(Pseudo: MI->getOpcode());
1210 if (!RVV)
1211 return false;
1212
1213 OutMI.setOpcode(RVV->BaseInstr);
1214
1215 const TargetInstrInfo *TII = STI->getInstrInfo();
1216 const TargetRegisterInfo *TRI = STI->getRegisterInfo();
1217 assert(TRI && "TargetRegisterInfo expected");
1218
1219 const MCInstrDesc &MCID = MI->getDesc();
1220 uint64_t TSFlags = MCID.TSFlags;
1221 unsigned NumOps = MI->getNumExplicitOperands();
1222
1223 // Skip policy, SEW, VL, VXRM/FRM operands which are the last operands if
1224 // present.
1225 if (RISCVII::hasVecPolicyOp(TSFlags))
1226 --NumOps;
1227 if (RISCVII::hasSEWOp(TSFlags))
1228 --NumOps;
1229 if (RISCVII::hasVLOp(TSFlags))
1230 --NumOps;
1231 if (RISCVII::hasRoundModeOp(TSFlags))
1232 --NumOps;
1233 if (RISCVII::hasTWidenOp(TSFlags))
1234 --NumOps;
1235 if (RISCVII::hasTMOp(TSFlags))
1236 --NumOps;
1237 if (RISCVII::hasTKOp(TSFlags))
1238 --NumOps;
1239
1240 bool hasVLOutput = RISCVInstrInfo::isFaultOnlyFirstLoad(MI: *MI);
1241 for (unsigned OpNo = 0; OpNo != NumOps; ++OpNo) {
1242 const MachineOperand &MO = MI->getOperand(i: OpNo);
1243 // Skip vl output. It should be the second output.
1244 if (hasVLOutput && OpNo == 1)
1245 continue;
1246
1247 // Skip passthru op. It should be the first operand after the defs.
1248 if (OpNo == MI->getNumExplicitDefs() && MO.isReg() && MO.isTied()) {
1249 assert(MCID.getOperandConstraint(OpNo, MCOI::TIED_TO) == 0 &&
1250 "Expected tied to first def.");
1251 const MCInstrDesc &OutMCID = TII->get(Opcode: OutMI.getOpcode());
1252 // Skip if the next operand in OutMI is not supposed to be tied. Unless it
1253 // is a _TIED instruction.
1254 if (OutMCID.getOperandConstraint(OpNum: OutMI.getNumOperands(), Constraint: MCOI::TIED_TO) <
1255 0 &&
1256 !RISCVII::isTiedPseudo(TSFlags))
1257 continue;
1258 }
1259
1260 MCOperand MCOp;
1261 switch (MO.getType()) {
1262 default:
1263 llvm_unreachable("Unknown operand type");
1264 case MachineOperand::MO_Register: {
1265 Register Reg = MO.getReg();
1266
1267 if (RISCV::VRM2RegClass.contains(Reg) ||
1268 RISCV::VRM4RegClass.contains(Reg) ||
1269 RISCV::VRM8RegClass.contains(Reg)) {
1270 Reg = TRI->getSubReg(Reg, Idx: RISCV::sub_vrm1_0);
1271 assert(Reg && "Subregister does not exist");
1272 } else if (RISCV::FPR16RegClass.contains(Reg)) {
1273 Reg =
1274 TRI->getMatchingSuperReg(Reg, SubIdx: RISCV::sub_16, RC: &RISCV::FPR32RegClass);
1275 assert(Reg && "Subregister does not exist");
1276 } else if (RISCV::FPR64RegClass.contains(Reg)) {
1277 Reg = TRI->getSubReg(Reg, Idx: RISCV::sub_32);
1278 assert(Reg && "Superregister does not exist");
1279 } else if (RISCV::VRN2M1RegClass.contains(Reg) ||
1280 RISCV::VRN2M2RegClass.contains(Reg) ||
1281 RISCV::VRN2M4RegClass.contains(Reg) ||
1282 RISCV::VRN3M1RegClass.contains(Reg) ||
1283 RISCV::VRN3M2RegClass.contains(Reg) ||
1284 RISCV::VRN4M1RegClass.contains(Reg) ||
1285 RISCV::VRN4M2RegClass.contains(Reg) ||
1286 RISCV::VRN5M1RegClass.contains(Reg) ||
1287 RISCV::VRN6M1RegClass.contains(Reg) ||
1288 RISCV::VRN7M1RegClass.contains(Reg) ||
1289 RISCV::VRN8M1RegClass.contains(Reg)) {
1290 Reg = TRI->getSubReg(Reg, Idx: RISCV::sub_vrm1_0);
1291 assert(Reg && "Subregister does not exist");
1292 }
1293
1294 MCOp = MCOperand::createReg(Reg);
1295 break;
1296 }
1297 case MachineOperand::MO_Immediate:
1298 MCOp = MCOperand::createImm(Val: MO.getImm());
1299 break;
1300 }
1301 OutMI.addOperand(Op: MCOp);
1302 }
1303
1304 // Unmasked pseudo instructions need to append dummy mask operand to
1305 // V instructions. All V instructions are modeled as the masked version.
1306 const MCInstrDesc &OutMCID = TII->get(Opcode: OutMI.getOpcode());
1307 if (OutMI.getNumOperands() < OutMCID.getNumOperands()) {
1308 assert(OutMCID.operands()[OutMI.getNumOperands()].OperandType ==
1309 RISCVOp::OPERAND_VMASK &&
1310 "Expected only mask operand to be missing");
1311 OutMI.addOperand(Op: MCOperand::createReg(Reg: RISCV::NoRegister));
1312 }
1313
1314 assert(OutMI.getNumOperands() == OutMCID.getNumOperands());
1315 return true;
1316}
1317
1318void RISCVAsmPrinter::lowerToMCInst(const MachineInstr *MI, MCInst &OutMI) {
1319 if (lowerRISCVVMachineInstrToMCInst(MI, OutMI, STI))
1320 return;
1321
1322 OutMI.setOpcode(MI->getOpcode());
1323
1324 for (const MachineOperand &MO : MI->operands()) {
1325 MCOperand MCOp;
1326 if (lowerOperand(MO, MCOp))
1327 OutMI.addOperand(Op: MCOp);
1328 }
1329}
1330
1331void RISCVAsmPrinter::emitMachineConstantPoolValue(
1332 MachineConstantPoolValue *MCPV) {
1333 auto *RCPV = static_cast<RISCVConstantPoolValue *>(MCPV);
1334 MCSymbol *MCSym;
1335
1336 if (RCPV->isGlobalValue()) {
1337 auto *GV = RCPV->getGlobalValue();
1338 MCSym = getSymbol(GV);
1339 } else {
1340 assert(RCPV->isExtSymbol() && "unrecognized constant pool type");
1341 auto Sym = RCPV->getSymbol();
1342 MCSym = GetExternalSymbolSymbol(Sym);
1343 }
1344
1345 const MCExpr *Expr = MCSymbolRefExpr::create(Symbol: MCSym, Ctx&: OutContext);
1346 uint64_t Size = getDataLayout().getTypeAllocSize(Ty: RCPV->getType());
1347 OutStreamer->emitValue(Value: Expr, Size);
1348}
1349
1350MaybeAlign
1351RISCVAsmPrinter::getRequiredGlobalAlignmentGranule(const GlobalVariable &GV) {
1352 const MCSubtargetInfo &MCSTI = TM.getMCSubtargetInfo();
1353 if (!GV.getValueType()->isSized())
1354 return std::nullopt;
1355
1356 // When the alignment granule is determined by a CHERI requirement,
1357 // don't increase alignment if a custom section has been specified,
1358 // as doing so can break existing code that relies on the lack of
1359 // padding (e.g. linker sets).
1360 if (GV.hasSection())
1361 return std::nullopt;
1362
1363 uint64_t Size = GV.getGlobalSize(DL: getDataLayout());
1364 if (MCSTI.hasFeature(Feature: RISCV::FeatureVendorXCheriot))
1365 return CHERIoTCapabilityFormat::getRequiredAlignment(Length: Size);
1366
1367 if (MCSTI.hasFeature(Feature: RISCV::FeatureStdExtY)) {
1368 if (MCSTI.hasFeature(Feature: RISCV::Feature64Bit))
1369 return RV64YCapabilityFormat::getRequiredAlignment(Length: Size);
1370 else
1371 return RV32YCapabilityFormat::getRequiredAlignment(Length: Size);
1372 }
1373
1374 return std::nullopt;
1375}
1376
1377char RISCVAsmPrinter::ID = 0;
1378
1379INITIALIZE_PASS(RISCVAsmPrinter, "riscv-asm-printer", "RISC-V Assembly Printer",
1380 false, false)
1381
1382PreservedAnalyses RISCVAsmPrinterBeginPass::run(Module &M,
1383 ModuleAnalysisManager &MAM) {
1384 RISCVAsmPrinter &AsmPrinter = static_cast<RISCVAsmPrinter &>(
1385 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
1386 setupModuleAsmPrinter(M, MAM, AsmPrinter);
1387 AsmPrinter.doInitialization(M);
1388 return PreservedAnalyses::all();
1389}
1390
1391PreservedAnalyses
1392RISCVAsmPrinterPass::run(MachineFunction &MF,
1393 MachineFunctionAnalysisManager &MFAM) {
1394 RISCVAsmPrinter &AsmPrinter = static_cast<RISCVAsmPrinter &>(
1395 MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(IR&: MF)
1396 .getCachedResult<AsmPrinterAnalysis>(IR&: *MF.getFunction().getParent())
1397 ->getPrinter());
1398 setupMachineFunctionAsmPrinter(MFAM, MF, AsmPrinter);
1399 AsmPrinter.runOnMachineFunction(MF);
1400 return PreservedAnalyses::all();
1401}
1402
1403PreservedAnalyses RISCVAsmPrinterEndPass::run(Module &M,
1404 ModuleAnalysisManager &MAM) {
1405 RISCVAsmPrinter &AsmPrinter = static_cast<RISCVAsmPrinter &>(
1406 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
1407 setupModuleAsmPrinter(M, MAM, AsmPrinter);
1408 AsmPrinter.doFinalization(M);
1409 return PreservedAnalyses::all();
1410}
1411