LLVM: lib/Target/X86/X86AsmPrinter.cpp Source File

LLVM 22.0.0git
X86AsmPrinter.cpp
Go to the documentation of this file.
1//===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===//
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 X86 machine code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "X86AsmPrinter.h"
15#include "MCTargetDesc/X86ATTInstPrinter.h"
16#include "MCTargetDesc/X86BaseInfo.h"
17#include "MCTargetDesc/X86MCTargetDesc.h"
18#include "MCTargetDesc/X86TargetStreamer.h"
19#include "TargetInfo/X86TargetInfo.h"
20#include "X86.h"
21#include "X86InstrInfo.h"
22#include "X86MachineFunctionInfo.h"
23#include "X86Subtarget.h"
24#include "llvm-c/Visibility.h"
25#include "llvm/Analysis/StaticDataProfileInfo.h"
26#include "llvm/BinaryFormat/COFF.h"
27#include "llvm/BinaryFormat/ELF.h"
28#include "llvm/CodeGen/MachineConstantPool.h"
29#include "llvm/CodeGen/MachineModuleInfoImpls.h"
30#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
31#include "llvm/CodeGenTypes/MachineValueType.h"
32#include "llvm/IR/DerivedTypes.h"
33#include "llvm/IR/InlineAsm.h"
34#include "llvm/IR/InstIterator.h"
35#include "llvm/IR/Mangler.h"
36#include "llvm/IR/Module.h"
37#include "llvm/IR/Type.h"
38#include "llvm/MC/MCAsmInfo.h"
39#include "llvm/MC/MCCodeEmitter.h"
40#include "llvm/MC/MCContext.h"
41#include "llvm/MC/MCExpr.h"
42#include "llvm/MC/MCInst.h"
43#include "llvm/MC/MCInstBuilder.h"
44#include "llvm/MC/MCSectionCOFF.h"
45#include "llvm/MC/MCSectionELF.h"
46#include "llvm/MC/MCSectionMachO.h"
47#include "llvm/MC/MCStreamer.h"
48#include "llvm/MC/MCSymbol.h"
49#include "llvm/MC/TargetRegistry.h"
50#include "llvm/Support/Debug.h"
51#include "llvm/Support/ErrorHandling.h"
52#include "llvm/Target/TargetMachine.h"
53
54using namespace llvm;
55
57 std::unique_ptr<MCStreamer> Streamer)
58 : AsmPrinter(TM, std::move(Streamer), ID), FM(*this) {}
59
60//===----------------------------------------------------------------------===//
61// Primitive Helper Functions.
62//===----------------------------------------------------------------------===//
63
64/// runOnMachineFunction - Emit the function body.
65///
68 PSI = &PSIW->getPSI();
70 SDPI = &SDPIW->getStaticDataProfileInfo();
71
72 Subtarget = &MF.getSubtarget<X86Subtarget>();
73
74 SMShadowTracker.startFunction(MF);
75 CodeEmitter.reset(TM.getTarget().createMCCodeEmitter(
76 *Subtarget->getInstrInfo(), MF.getContext()));
77
78 const Module *M = MF.getFunction().getParent();
79 EmitFPOData = Subtarget->isTargetWin32() && M->getCodeViewFlag();
80
81 IndCSPrefix = M->getModuleFlag("indirect_branch_cs_prefix");
82
84
85 if (Subtarget->isTargetCOFF()) {
86 bool Local = MF.getFunction().hasLocalLinkage();
87 OutStreamer->beginCOFFSymbolDef(CurrentFnSym);
88 OutStreamer->emitCOFFSymbolStorageClass(
92 OutStreamer->endCOFFSymbolDef();
93 }
94
95 // Emit the rest of the function body.
97
98 // Emit the XRay table for this function.
100
101 EmitFPOData = false;
102
103 IndCSPrefix = false;
104
105 // We didn't modify anything.
106 return false;
107}
108
110 if (EmitFPOData) {
111 auto *XTS =
112 static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
113 XTS->emitFPOProc(
116 }
117}
118
120 if (EmitFPOData) {
121 auto *XTS =
122 static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
123 XTS->emitFPOEndProc();
124 }
125}
126
127uint32_t X86AsmPrinter::MaskKCFIType(uint32_t Value) {
128 // If the type hash matches an invalid pattern, mask the value.
129 const uint32_t InvalidValues[] = {
130 0xFA1E0FF3, /* ENDBR64 */
131 0xFB1E0FF3, /* ENDBR32 */
132 };
133 for (uint32_t N : InvalidValues) {
134 // LowerKCFI_CHECK emits -Value for indirect call checks, so we must also
135 // mask that. Note that -(Value + 1) == ~Value.
136 if (N == Value || -N == Value)
137 return Value + 1;
138 }
139 return Value;
140}
141
142void X86AsmPrinter::EmitKCFITypePadding(const MachineFunction &MF,
143 bool HasType) {
144 // Keep the function entry aligned, taking patchable-function-prefix into
145 // account if set.
146 int64_t PrefixBytes = 0;
147 (void)MF.getFunction()
148 .getFnAttribute("patchable-function-prefix")
149 .getValueAsString()
150 .getAsInteger(10, PrefixBytes);
151
152 // Also take the type identifier into account if we're emitting
153 // one. Otherwise, just pad with nops. The X86::MOV32ri instruction emitted
154 // in X86AsmPrinter::emitKCFITypeId is 5 bytes long.
155 if (HasType)
156 PrefixBytes += 5;
157
158 emitNops(offsetToAlignment(PrefixBytes, MF.getAlignment()));
159}
160
161/// emitKCFITypeId - Emit the KCFI type information in architecture specific
162/// format.
164 const Function &F = MF.getFunction();
165 if (!F.getParent()->getModuleFlag("kcfi"))
166 return;
167
168 ConstantInt *Type = nullptr;
169 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_kcfi_type))
170 Type = mdconst::extract<ConstantInt>(MD->getOperand(0));
171
172 // If we don't have a type to emit, just emit padding if needed to maintain
173 // the same alignment for all functions.
174 if (!Type) {
175 EmitKCFITypePadding(MF, /*HasType=*/false);
176 return;
177 }
178
179 // Emit a function symbol for the type data to avoid unreachable instruction
180 // warnings from binary validation tools, and use the same linkage as the
181 // parent function. Note that using local linkage would result in duplicate
182 // symbols for weak parent functions.
183 MCSymbol *FnSym = OutContext.getOrCreateSymbol("__cfi_" + MF.getName());
184 emitLinkage(&MF.getFunction(), FnSym);
185 if (MAI->hasDotTypeDotSizeDirective())
186 OutStreamer->emitSymbolAttribute(FnSym, MCSA_ELF_TypeFunction);
187 OutStreamer->emitLabel(FnSym);
188
189 // Embed the type hash in the X86::MOV32ri instruction to avoid special
190 // casing object file parsers.
191 EmitKCFITypePadding(MF);
192 unsigned DestReg = X86::EAX;
193
194 if (F.getParent()->getModuleFlag("kcfi-arity")) {
195 // The ArityToRegMap assumes the 64-bit SysV ABI.
196 [[maybe_unused]] const auto &Triple = MF.getTarget().getTargetTriple();
198
199 // Determine the function's arity (i.e., the number of arguments) at the ABI
200 // level by counting the number of parameters that are passed
201 // as registers, such as pointers and 64-bit (or smaller) integers. The
202 // Linux x86-64 ABI allows up to 6 integer parameters to be passed in GPRs.
203 // Additional parameters or parameters larger than 64 bits may be passed on
204 // the stack, in which case the arity is denoted as 7. Floating-point
205 // arguments passed in XMM0-XMM7 are not counted toward arity because
206 // floating-point values are not relevant to enforcing kCFI at this time.
207 const unsigned ArityToRegMap[8] = {X86::EAX, X86::ECX, X86::EDX, X86::EBX,
208 X86::ESP, X86::EBP, X86::ESI, X86::EDI};
209 int Arity;
210 if (MF.getInfo<X86MachineFunctionInfo>()->getArgumentStackSize() > 0) {
211 Arity = 7;
212 } else {
213 Arity = 0;
214 for (const auto &LI : MF.getRegInfo().liveins()) {
215 auto Reg = LI.first;
216 if (X86::GR8RegClass.contains(Reg) || X86::GR16RegClass.contains(Reg) ||
217 X86::GR32RegClass.contains(Reg) ||
218 X86::GR64RegClass.contains(Reg)) {
219 ++Arity;
220 }
221 }
222 }
223 DestReg = ArityToRegMap[Arity];
224 }
225
226 EmitAndCountInstruction(MCInstBuilder(X86::MOV32ri)
227 .addReg(DestReg)
228 .addImm(MaskKCFIType(Type->getZExtValue())));
229
230 if (MAI->hasDotTypeDotSizeDirective()) {
231 MCSymbol *EndSym = OutContext.createTempSymbol("cfi_func_end");
232 OutStreamer->emitLabel(EndSym);
233
234 const MCExpr *SizeExp = MCBinaryExpr::createSub(
237 OutStreamer->emitELFSize(FnSym, SizeExp);
238 }
239}
240
241/// PrintSymbolOperand - Print a raw symbol reference operand. This handles
242/// jump tables, constant pools, global address and external symbols, all of
243/// which print to a label with various suffixes for relocation types etc.
244void X86AsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
245 raw_ostream &O) {
246 switch (MO.getType()) {
247 default: llvm_unreachable("unknown symbol type!");
248 case MachineOperand::MO_ConstantPoolIndex:
249 GetCPISymbol(MO.getIndex())->print(O, MAI);
250 printOffset(MO.getOffset(), O);
251 break;
252 case MachineOperand::MO_GlobalAddress: {
253 const GlobalValue *GV = MO.getGlobal();
254
255 MCSymbol *GVSym;
256 if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
257 MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE)
258 GVSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
259 else
260 GVSym = getSymbolPreferLocal(*GV);
261
262 // Handle dllimport linkage.
263 if (MO.getTargetFlags() == X86II::MO_DLLIMPORT)
264 GVSym = OutContext.getOrCreateSymbol(Twine("__imp_") + GVSym->getName());
265 else if (MO.getTargetFlags() == X86II::MO_COFFSTUB)
266 GVSym =
267 OutContext.getOrCreateSymbol(Twine(".refptr.") + GVSym->getName());
268
269 if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
270 MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE) {
271 MCSymbol *Sym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
272 MachineModuleInfoImpl::StubValueTy &StubSym =
273 MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);
274 if (!StubSym.getPointer())
275 StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(GV),
276 !GV->hasInternalLinkage());
277 }
278
279 // If the name begins with a dollar-sign, enclose it in parens. We do this
280 // to avoid having it look like an integer immediate to the assembler.
281 if (GVSym->getName()[0] != '$')
282 GVSym->print(O, MAI);
283 else {
284 O << '(';
285 GVSym->print(O, MAI);
286 O << ')';
287 }
288 printOffset(MO.getOffset(), O);
289 break;
290 }
291 }
292
293 switch (MO.getTargetFlags()) {
294 default:
295 llvm_unreachable("Unknown target flag on GV operand");
296 case X86II::MO_NO_FLAG: // No flag.
297 break;
298 case X86II::MO_DARWIN_NONLAZY:
299 case X86II::MO_DLLIMPORT:
300 case X86II::MO_COFFSTUB:
301 // These affect the name of the symbol, not any suffix.
302 break;
303 case X86II::MO_GOT_ABSOLUTE_ADDRESS:
304 O << " + [.-";
305 MF->getPICBaseSymbol()->print(O, MAI);
306 O << ']';
307 break;
308 case X86II::MO_PIC_BASE_OFFSET:
309 case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
310 O << '-';
311 MF->getPICBaseSymbol()->print(O, MAI);
312 break;
313 case X86II::MO_TLSGD: O << "@TLSGD"; break;
314 case X86II::MO_TLSLD: O << "@TLSLD"; break;
315 case X86II::MO_TLSLDM: O << "@TLSLDM"; break;
316 case X86II::MO_GOTTPOFF: O << "@GOTTPOFF"; break;
317 case X86II::MO_INDNTPOFF: O << "@INDNTPOFF"; break;
318 case X86II::MO_TPOFF: O << "@TPOFF"; break;
319 case X86II::MO_DTPOFF: O << "@DTPOFF"; break;
320 case X86II::MO_NTPOFF: O << "@NTPOFF"; break;
321 case X86II::MO_GOTNTPOFF: O << "@GOTNTPOFF"; break;
322 case X86II::MO_GOTPCREL: O << "@GOTPCREL"; break;
323 case X86II::MO_GOTPCREL_NORELAX: O << "@GOTPCREL_NORELAX"; break;
324 case X86II::MO_GOT: O << "@GOT"; break;
325 case X86II::MO_GOTOFF: O << "@GOTOFF"; break;
326 case X86II::MO_PLT: O << "@PLT"; break;
327 case X86II::MO_TLVP: O << "@TLVP"; break;
328 case X86II::MO_TLVP_PIC_BASE:
329 O << "@TLVP" << '-';
330 MF->getPICBaseSymbol()->print(O, MAI);
331 break;
332 case X86II::MO_SECREL: O << "@SECREL32"; break;
333 }
334}
335
336void X86AsmPrinter::PrintOperand(const MachineInstr *MI, unsigned OpNo,
337 raw_ostream &O) {
338 const MachineOperand &MO = MI->getOperand(OpNo);
339 const bool IsATT = MI->getInlineAsmDialect() == InlineAsm::AD_ATT;
340 switch (MO.getType()) {
341 default: llvm_unreachable("unknown operand type!");
342 case MachineOperand::MO_Register: {
343 if (IsATT)
344 O << '%';
345 O << X86ATTInstPrinter::getRegisterName(MO.getReg());
346 return;
347 }
348
349 case MachineOperand::MO_Immediate:
350 if (IsATT)
351 O << '$';
352 O << MO.getImm();
353 return;
354
355 case MachineOperand::MO_ConstantPoolIndex:
356 case MachineOperand::MO_GlobalAddress: {
357 switch (MI->getInlineAsmDialect()) {
358 case InlineAsm::AD_ATT:
359 O << '$';
360 break;
361 case InlineAsm::AD_Intel:
362 O << "offset ";
363 break;
364 }
365 PrintSymbolOperand(MO, O);
366 break;
367 }
368 case MachineOperand::MO_BlockAddress: {
369 MCSymbol *Sym = GetBlockAddressSymbol(MO.getBlockAddress());
370 Sym->print(O, MAI);
371 break;
372 }
373 }
374}
375
376/// PrintModifiedOperand - Print subregisters based on supplied modifier,
377/// deferring to PrintOperand() if no modifier was supplied or if operand is not
378/// a register.
379void X86AsmPrinter::PrintModifiedOperand(const MachineInstr *MI, unsigned OpNo,
380 raw_ostream &O, StringRef Modifier) {
381 const MachineOperand &MO = MI->getOperand(OpNo);
382 if (Modifier.empty() || !MO.isReg())
383 return PrintOperand(MI, OpNo, O);
384 if (MI->getInlineAsmDialect() == InlineAsm::AD_ATT)
385 O << '%';
386 Register Reg = MO.getReg();
387 if (Modifier.consume_front("subreg")) {
388 unsigned Size = (Modifier == "64") ? 64
389 : (Modifier == "32") ? 32
390 : (Modifier == "16") ? 16
391 : 8;
392 Reg = getX86SubSuperRegister(Reg, Size);
393 }
394 O << X86ATTInstPrinter::getRegisterName(Reg);
395}
396
397/// PrintPCRelImm - This is used to print an immediate value that ends up
398/// being encoded as a pc-relative value. These print slightly differently, for
399/// example, a $ is not emitted.
400void X86AsmPrinter::PrintPCRelImm(const MachineInstr *MI, unsigned OpNo,
401 raw_ostream &O) {
402 const MachineOperand &MO = MI->getOperand(OpNo);
403 switch (MO.getType()) {
404 default: llvm_unreachable("Unknown pcrel immediate operand");
405 case MachineOperand::MO_Register:
406 // pc-relativeness was handled when computing the value in the reg.
407 PrintOperand(MI, OpNo, O);
408 return;
409 case MachineOperand::MO_Immediate:
410 O << MO.getImm();
411 return;
412 case MachineOperand::MO_GlobalAddress:
413 PrintSymbolOperand(MO, O);
414 return;
415 }
416}
417
418void X86AsmPrinter::PrintLeaMemReference(const MachineInstr *MI, unsigned OpNo,
419 raw_ostream &O, StringRef Modifier) {
420 const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
421 const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
422 const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
423
424 // If we really don't want to print out (rip), don't.
425 bool HasBaseReg = BaseReg.getReg() != 0;
426 if (HasBaseReg && Modifier == "no-rip" && BaseReg.getReg() == X86::RIP)
427 HasBaseReg = false;
428
429 // HasParenPart - True if we will print out the () part of the mem ref.
430 bool HasParenPart = IndexReg.getReg() || HasBaseReg;
431
432 switch (DispSpec.getType()) {
433 default:
434 llvm_unreachable("unknown operand type!");
435 case MachineOperand::MO_Immediate: {
436 int DispVal = DispSpec.getImm();
437 if (DispVal || !HasParenPart)
438 O << DispVal;
439 break;
440 }
441 case MachineOperand::MO_GlobalAddress:
442 case MachineOperand::MO_ConstantPoolIndex:
443 PrintSymbolOperand(DispSpec, O);
444 break;
445 }
446
447 if (Modifier == "H")
448 O << "+8";
449
450 if (HasParenPart) {
451 assert(IndexReg.getReg() != X86::ESP &&
452 "X86 doesn't allow scaling by ESP");
453
454 O << '(';
455 if (HasBaseReg)
456 PrintModifiedOperand(MI, OpNo + X86::AddrBaseReg, O, Modifier);
457
458 if (IndexReg.getReg()) {
459 O << ',';
460 PrintModifiedOperand(MI, OpNo + X86::AddrIndexReg, O, Modifier);
461 unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
462 if (ScaleVal != 1)
463 O << ',' << ScaleVal;
464 }
465 O << ')';
466 }
467}
468
469 static bool isSimpleReturn(const MachineInstr &MI) {
470 // We exclude all tail calls here which set both isReturn and isCall.
471 return MI.getDesc().isReturn() && !MI.getDesc().isCall();
472}
473
475 unsigned Opc = MI.getOpcode();
476 return MI.getDesc().isIndirectBranch() /*Make below code in a good shape*/ ||
477 Opc == X86::TAILJMPr || Opc == X86::TAILJMPm ||
478 Opc == X86::TAILJMPr64 || Opc == X86::TAILJMPm64 ||
479 Opc == X86::TCRETURNri || Opc == X86::TCRETURN_WIN64ri ||
480 Opc == X86::TCRETURN_HIPE32ri || Opc == X86::TCRETURNmi ||
481 Opc == X86::TCRETURN_WINmi64 || Opc == X86::TCRETURNri64 ||
482 Opc == X86::TCRETURNmi64 || Opc == X86::TCRETURNri64_ImpCall ||
483 Opc == X86::TAILJMPr64_REX || Opc == X86::TAILJMPm64_REX;
484}
485
487 if (Subtarget->hardenSlsRet() || Subtarget->hardenSlsIJmp()) {
488 auto I = MBB.getLastNonDebugInstr();
489 if (I != MBB.end()) {
490 if ((Subtarget->hardenSlsRet() && isSimpleReturn(*I)) ||
491 (Subtarget->hardenSlsIJmp() && isIndirectBranchOrTailCall(*I))) {
492 MCInst TmpInst;
493 TmpInst.setOpcode(X86::INT3);
494 EmitToStreamer(*OutStreamer, TmpInst);
495 }
496 }
497 }
499 SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
500}
501
502void X86AsmPrinter::PrintMemReference(const MachineInstr *MI, unsigned OpNo,
503 raw_ostream &O, StringRef Modifier) {
504 assert(isMem(*MI, OpNo) && "Invalid memory reference!");
505 const MachineOperand &Segment = MI->getOperand(OpNo + X86::AddrSegmentReg);
506 if (Segment.getReg()) {
507 PrintModifiedOperand(MI, OpNo + X86::AddrSegmentReg, O, Modifier);
508 O << ':';
509 }
510 PrintLeaMemReference(MI, OpNo, O, Modifier);
511}
512
513void X86AsmPrinter::PrintIntelMemReference(const MachineInstr *MI,
514 unsigned OpNo, raw_ostream &O,
515 StringRef Modifier) {
516 const MachineOperand &BaseReg = MI->getOperand(OpNo + X86::AddrBaseReg);
517 unsigned ScaleVal = MI->getOperand(OpNo + X86::AddrScaleAmt).getImm();
518 const MachineOperand &IndexReg = MI->getOperand(OpNo + X86::AddrIndexReg);
519 const MachineOperand &DispSpec = MI->getOperand(OpNo + X86::AddrDisp);
520 const MachineOperand &SegReg = MI->getOperand(OpNo + X86::AddrSegmentReg);
521
522 // If we really don't want to print out (rip), don't.
523 bool HasBaseReg = BaseReg.getReg() != 0;
524 if (HasBaseReg && Modifier == "no-rip" && BaseReg.getReg() == X86::RIP)
525 HasBaseReg = false;
526
527 // If we really just want to print out displacement.
528 if ((DispSpec.isGlobal() || DispSpec.isSymbol()) && Modifier == "disp-only") {
529 HasBaseReg = false;
530 }
531
532 // If this has a segment register, print it.
533 if (SegReg.getReg()) {
534 PrintOperand(MI, OpNo + X86::AddrSegmentReg, O);
535 O << ':';
536 }
537
538 O << '[';
539
540 bool NeedPlus = false;
541 if (HasBaseReg) {
542 PrintOperand(MI, OpNo + X86::AddrBaseReg, O);
543 NeedPlus = true;
544 }
545
546 if (IndexReg.getReg()) {
547 if (NeedPlus) O << " + ";
548 if (ScaleVal != 1)
549 O << ScaleVal << '*';
550 PrintOperand(MI, OpNo + X86::AddrIndexReg, O);
551 NeedPlus = true;
552 }
553
554 if (!DispSpec.isImm()) {
555 if (NeedPlus) O << " + ";
556 // Do not add `offset` operator. Matches the behaviour of
557 // X86IntelInstPrinter::printMemReference.
558 PrintSymbolOperand(DispSpec, O);
559 } else {
560 int64_t DispVal = DispSpec.getImm();
561 if (DispVal || (!IndexReg.getReg() && !HasBaseReg)) {
562 if (NeedPlus) {
563 if (DispVal > 0)
564 O << " + ";
565 else {
566 O << " - ";
567 DispVal = -DispVal;
568 }
569 }
570 O << DispVal;
571 }
572 }
573 O << ']';
574}
575
576const MCSubtargetInfo *X86AsmPrinter::getIFuncMCSubtargetInfo() const {
577 assert(Subtarget);
578 return Subtarget;
579}
580
581void X86AsmPrinter::emitMachOIFuncStubBody(Module &M, const GlobalIFunc &GI,
582 MCSymbol *LazyPointer) {
583 // _ifunc:
584 // jmpq *lazy_pointer(%rip)
585
586 OutStreamer->emitInstruction(
587 MCInstBuilder(X86::JMP32m)
588 .addReg(X86::RIP)
589 .addImm(1)
590 .addReg(0)
591 .addOperand(MCOperand::createExpr(
592 MCSymbolRefExpr::create(LazyPointer, OutContext)))
593 .addReg(0),
594 *Subtarget);
595}
596
597void X86AsmPrinter::emitMachOIFuncStubHelperBody(Module &M,
598 const GlobalIFunc &GI,
599 MCSymbol *LazyPointer) {
600 // _ifunc.stub_helper:
601 // push %rax
602 // push %rdi
603 // push %rsi
604 // push %rdx
605 // push %rcx
606 // push %r8
607 // push %r9
608 // callq foo
609 // movq %rax,lazy_pointer(%rip)
610 // pop %r9
611 // pop %r8
612 // pop %rcx
613 // pop %rdx
614 // pop %rsi
615 // pop %rdi
616 // pop %rax
617 // jmpq *lazy_pointer(%rip)
618
619 for (int Reg :
620 {X86::RAX, X86::RDI, X86::RSI, X86::RDX, X86::RCX, X86::R8, X86::R9})
621 OutStreamer->emitInstruction(MCInstBuilder(X86::PUSH64r).addReg(Reg),
622 *Subtarget);
623
624 OutStreamer->emitInstruction(
625 MCInstBuilder(X86::CALL64pcrel32)
626 .addOperand(MCOperand::createExpr(lowerConstant(GI.getResolver()))),
627 *Subtarget);
628
629 OutStreamer->emitInstruction(
630 MCInstBuilder(X86::MOV64mr)
631 .addReg(X86::RIP)
632 .addImm(1)
633 .addReg(0)
634 .addOperand(MCOperand::createExpr(
635 MCSymbolRefExpr::create(LazyPointer, OutContext)))
636 .addReg(0)
637 .addReg(X86::RAX),
638 *Subtarget);
639
640 for (int Reg :
641 {X86::R9, X86::R8, X86::RCX, X86::RDX, X86::RSI, X86::RDI, X86::RAX})
642 OutStreamer->emitInstruction(MCInstBuilder(X86::POP64r).addReg(Reg),
643 *Subtarget);
644
645 OutStreamer->emitInstruction(
646 MCInstBuilder(X86::JMP32m)
647 .addReg(X86::RIP)
648 .addImm(1)
649 .addReg(0)
650 .addOperand(MCOperand::createExpr(
651 MCSymbolRefExpr::create(LazyPointer, OutContext)))
652 .addReg(0),
653 *Subtarget);
654}
655
656 static bool printAsmMRegister(const X86AsmPrinter &P, const MachineOperand &MO,
657 char Mode, raw_ostream &O) {
658 Register Reg = MO.getReg();
659 bool EmitPercent = MO.getParent()->getInlineAsmDialect() == InlineAsm::AD_ATT;
660
661 if (!X86::GR8RegClass.contains(Reg) &&
662 !X86::GR16RegClass.contains(Reg) &&
663 !X86::GR32RegClass.contains(Reg) &&
664 !X86::GR64RegClass.contains(Reg))
665 return true;
666
667 switch (Mode) {
668 default: return true; // Unknown mode.
669 case 'b': // Print QImode register
671 break;
672 case 'h': // Print QImode high register
673 Reg = getX86SubSuperRegister(Reg, 8, true);
674 if (!Reg.isValid())
675 return true;
676 break;
677 case 'w': // Print HImode register
679 break;
680 case 'k': // Print SImode register
682 break;
683 case 'V':
684 EmitPercent = false;
685 [[fallthrough]];
686 case 'q':
687 // Print 64-bit register names if 64-bit integer registers are available.
688 // Otherwise, print 32-bit register names.
689 Reg = getX86SubSuperRegister(Reg, P.getSubtarget().is64Bit() ? 64 : 32);
690 break;
691 }
692
693 if (EmitPercent)
694 O << '%';
695
697 return false;
698}
699
700 static bool printAsmVRegister(const MachineOperand &MO, char Mode,
701 raw_ostream &O) {
702 Register Reg = MO.getReg();
703 bool EmitPercent = MO.getParent()->getInlineAsmDialect() == InlineAsm::AD_ATT;
704
705 unsigned Index;
706 if (X86::VR128XRegClass.contains(Reg))
707 Index = Reg - X86::XMM0;
708 else if (X86::VR256XRegClass.contains(Reg))
709 Index = Reg - X86::YMM0;
710 else if (X86::VR512RegClass.contains(Reg))
711 Index = Reg - X86::ZMM0;
712 else
713 return true;
714
715 switch (Mode) {
716 default: // Unknown mode.
717 return true;
718 case 'x': // Print V4SFmode register
719 Reg = X86::XMM0 + Index;
720 break;
721 case 't': // Print V8SFmode register
722 Reg = X86::YMM0 + Index;
723 break;
724 case 'g': // Print V16SFmode register
725 Reg = X86::ZMM0 + Index;
726 break;
727 }
728
729 if (EmitPercent)
730 O << '%';
731
733 return false;
734}
735
736/// PrintAsmOperand - Print out an operand for an inline asm expression.
737///
739 const char *ExtraCode, raw_ostream &O) {
740 // Does this asm operand have a single letter operand modifier?
741 if (ExtraCode && ExtraCode[0]) {
742 if (ExtraCode[1] != 0) return true; // Unknown modifier.
743
744 const MachineOperand &MO = MI->getOperand(OpNo);
745
746 switch (ExtraCode[0]) {
747 default:
748 // See if this is a generic print operand
749 return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, O);
750 case 'a': // This is an address. Currently only 'i' and 'r' are expected.
751 switch (MO.getType()) {
752 default:
753 return true;
755 O << MO.getImm();
756 return false;
760 llvm_unreachable("unexpected operand type!");
762 PrintSymbolOperand(MO, O);
763 if (Subtarget->is64Bit())
764 O << "(%rip)";
765 return false;
767 O << '(';
768 PrintOperand(MI, OpNo, O);
769 O << ')';
770 return false;
771 }
772
773 case 'c': // Don't print "$" before a global var name or constant.
774 switch (MO.getType()) {
775 default:
776 PrintOperand(MI, OpNo, O);
777 break;
779 O << MO.getImm();
780 break;
784 llvm_unreachable("unexpected operand type!");
786 PrintSymbolOperand(MO, O);
787 break;
788 }
789 return false;
790
791 case 'A': // Print '*' before a register (it must be a register)
792 if (MO.isReg()) {
793 O << '*';
794 PrintOperand(MI, OpNo, O);
795 return false;
796 }
797 return true;
798
799 case 'b': // Print QImode register
800 case 'h': // Print QImode high register
801 case 'w': // Print HImode register
802 case 'k': // Print SImode register
803 case 'q': // Print DImode register
804 case 'V': // Print native register without '%'
805 if (MO.isReg())
806 return printAsmMRegister(*this, MO, ExtraCode[0], O);
807 PrintOperand(MI, OpNo, O);
808 return false;
809
810 case 'x': // Print V4SFmode register
811 case 't': // Print V8SFmode register
812 case 'g': // Print V16SFmode register
813 if (MO.isReg())
814 return printAsmVRegister(MO, ExtraCode[0], O);
815 PrintOperand(MI, OpNo, O);
816 return false;
817
818 case 'p': {
819 const MachineOperand &MO = MI->getOperand(OpNo);
821 return true;
822 PrintSymbolOperand(MO, O);
823 return false;
824 }
825
826 case 'P': // This is the operand of a call, treat specially.
827 PrintPCRelImm(MI, OpNo, O);
828 return false;
829
830 case 'n': // Negate the immediate or print a '-' before the operand.
831 // Note: this is a temporary solution. It should be handled target
832 // independently as part of the 'MC' work.
833 if (MO.isImm()) {
834 O << -MO.getImm();
835 return false;
836 }
837 O << '-';
838 }
839 }
840
841 PrintOperand(MI, OpNo, O);
842 return false;
843}
844
846 const char *ExtraCode,
847 raw_ostream &O) {
848 if (ExtraCode && ExtraCode[0]) {
849 if (ExtraCode[1] != 0) return true; // Unknown modifier.
850
851 switch (ExtraCode[0]) {
852 default: return true; // Unknown modifier.
853 case 'b': // Print QImode register
854 case 'h': // Print QImode high register
855 case 'w': // Print HImode register
856 case 'k': // Print SImode register
857 case 'q': // Print SImode register
858 // These only apply to registers, ignore on mem.
859 break;
860 case 'H':
861 if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
862 return true; // Unsupported modifier in Intel inline assembly.
863 } else {
864 PrintMemReference(MI, OpNo, O, "H");
865 }
866 return false;
867 // Print memory only with displacement. The Modifer 'P' is used in inline
868 // asm to present a call symbol or a global symbol which can not use base
869 // reg or index reg.
870 case 'P':
871 if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
872 PrintIntelMemReference(MI, OpNo, O, "disp-only");
873 } else {
874 PrintMemReference(MI, OpNo, O, "disp-only");
875 }
876 return false;
877 }
878 }
879 if (MI->getInlineAsmDialect() == InlineAsm::AD_Intel) {
880 PrintIntelMemReference(MI, OpNo, O);
881 } else {
882 PrintMemReference(MI, OpNo, O);
883 }
884 return false;
885}
886
888 const Triple &TT = TM.getTargetTriple();
889
890 if (TT.isOSBinFormatELF()) {
891 // Assemble feature flags that may require creation of a note section.
892 unsigned FeatureFlagsAnd = 0;
893 if (M.getModuleFlag("cf-protection-branch"))
894 FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_IBT;
895 if (M.getModuleFlag("cf-protection-return"))
896 FeatureFlagsAnd |= ELF::GNU_PROPERTY_X86_FEATURE_1_SHSTK;
897
898 if (FeatureFlagsAnd) {
899 // Emit a .note.gnu.property section with the flags.
900 assert((TT.isX86_32() || TT.isX86_64()) &&
901 "CFProtection used on invalid architecture!");
902 MCSection *Cur = OutStreamer->getCurrentSectionOnly();
903 MCSection *Nt = MMI->getContext().getELFSection(
904 ".note.gnu.property", ELF::SHT_NOTE, ELF::SHF_ALLOC);
905 OutStreamer->switchSection(Nt);
906
907 // Emitting note header.
908 const int WordSize = TT.isX86_64() && !TT.isX32() ? 8 : 4;
909 emitAlignment(WordSize == 4 ? Align(4) : Align(8));
910 OutStreamer->emitIntValue(4, 4 /*size*/); // data size for "GNU0円"
911 OutStreamer->emitIntValue(8 + WordSize, 4 /*size*/); // Elf_Prop size
912 OutStreamer->emitIntValue(ELF::NT_GNU_PROPERTY_TYPE_0, 4 /*size*/);
913 OutStreamer->emitBytes(StringRef("GNU", 4)); // note name
914
915 // Emitting an Elf_Prop for the CET properties.
917 OutStreamer->emitInt32(4); // data size
918 OutStreamer->emitInt32(FeatureFlagsAnd); // data
919 emitAlignment(WordSize == 4 ? Align(4) : Align(8)); // padding
920
921 OutStreamer->switchSection(Cur);
922 }
923 }
924
925 if (TT.isOSBinFormatMachO())
926 OutStreamer->switchSection(getObjFileLowering().getTextSection());
927
928 if (TT.isOSBinFormatCOFF()) {
931
932 if (M.getModuleFlag("import-call-optimization"))
933 EnableImportCallOptimization = true;
934 }
935 OutStreamer->emitSyntaxDirective();
936
937 // If this is not inline asm and we're in 16-bit
938 // mode prefix assembly with .code16.
939 bool is16 = TT.getEnvironment() == Triple::CODE16;
940 if (M.getModuleInlineAsm().empty() && is16) {
941 auto *XTS =
942 static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
943 XTS->emitCode16();
944 }
945}
946
947static void
950 // L_foo$stub:
951 OutStreamer.emitLabel(StubLabel);
952 // .indirect_symbol _foo
954
955 if (MCSym.getInt())
956 // External to current translation unit.
957 OutStreamer.emitIntValue(0, 4/*size*/);
958 else
959 // Internal to current translation unit.
960 //
961 // When we place the LSDA into the TEXT section, the type info
962 // pointers need to be indirect and pc-rel. We accomplish this by
963 // using NLPs; however, sometimes the types are local to the file.
964 // We need to fill in the value for the NLP in those cases.
965 OutStreamer.emitValue(
966 MCSymbolRefExpr::create(MCSym.getPointer(), OutStreamer.getContext()),
967 4 /*size*/);
968}
969
970 static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer) {
971
972 MachineModuleInfoMachO &MMIMacho =
974
975 // Output stubs for dynamically-linked functions.
977
978 // Output stubs for external and common global variables.
979 Stubs = MMIMacho.GetGVStubList();
980 if (!Stubs.empty()) {
981 OutStreamer.switchSection(MMI->getContext().getMachOSection(
982 "__IMPORT", "__pointers", MachO::S_NON_LAZY_SYMBOL_POINTERS,
984
985 for (auto &Stub : Stubs)
986 emitNonLazySymbolPointer(OutStreamer, Stub.first, Stub.second);
987
988 Stubs.clear();
989 OutStreamer.addBlankLine();
990 }
991}
992
993/// True if this module is being built for windows/msvc, and uses floating
994/// point. This is used to emit an undefined reference to _fltused. This is
995/// needed in Windows kernel or driver contexts to find and prevent code from
996/// modifying non-GPR registers.
997///
998/// TODO: It would be better if this was computed from MIR by looking for
999/// selected floating-point instructions.
1000 static bool usesMSVCFloatingPoint(const Triple &TT, const Module &M) {
1001 // Only needed for MSVC
1002 if (!TT.isWindowsMSVCEnvironment())
1003 return false;
1004
1005 for (const Function &F : M) {
1006 for (const Instruction &I : instructions(F)) {
1007 if (I.getType()->isFloatingPointTy())
1008 return true;
1009
1010 for (const auto &Op : I.operands()) {
1011 if (Op->getType()->isFloatingPointTy())
1012 return true;
1013 }
1014 }
1015 }
1016
1017 return false;
1018}
1019
1021 const Triple &TT = TM.getTargetTriple();
1022
1023 if (TT.isOSBinFormatMachO()) {
1024 // Mach-O uses non-lazy symbol stubs to encode per-TU information into
1025 // global table for symbol lookup.
1027
1028 // Emit fault map information.
1029 FM.serializeToFaultMapSection();
1030
1031 // This flag tells the linker that no global symbols contain code that fall
1032 // through to other global symbols (e.g. an implementation of multiple entry
1033 // points). If this doesn't occur, the linker can safely perform dead code
1034 // stripping. Since LLVM never generates code that does this, it is always
1035 // safe to set.
1036 OutStreamer->emitSubsectionsViaSymbols();
1037 } else if (TT.isOSBinFormatCOFF()) {
1038 // If import call optimization is enabled, emit the appropriate section.
1039 // We do this whether or not we recorded any items.
1040 if (EnableImportCallOptimization) {
1041 OutStreamer->switchSection(getObjFileLowering().getImportCallSection());
1042
1043 // Section always starts with some magic.
1044 constexpr char ImpCallMagic[12] = "RetpolineV1";
1045 OutStreamer->emitBytes(StringRef{ImpCallMagic, sizeof(ImpCallMagic)});
1046
1047 // Layout of this section is:
1048 // Per section that contains an item to record:
1049 // uint32_t SectionSize: Size in bytes for information in this section.
1050 // uint32_t Section Number
1051 // Per call to imported function in section:
1052 // uint32_t Kind: the kind of item.
1053 // uint32_t InstOffset: the offset of the instr in its parent section.
1054 for (auto &[Section, CallsToImportedFuncs] :
1055 SectionToImportedFunctionCalls) {
1056 unsigned SectionSize =
1057 sizeof(uint32_t) * (2 + 2 * CallsToImportedFuncs.size());
1058 OutStreamer->emitInt32(SectionSize);
1059 OutStreamer->emitCOFFSecNumber(Section->getBeginSymbol());
1060 for (auto &[CallsiteSymbol, Kind] : CallsToImportedFuncs) {
1061 OutStreamer->emitInt32(Kind);
1062 OutStreamer->emitCOFFSecOffset(CallsiteSymbol);
1063 }
1064 }
1065 }
1066
1067 if (usesMSVCFloatingPoint(TT, M)) {
1068 // In Windows' libcmt.lib, there is a file which is linked in only if the
1069 // symbol _fltused is referenced. Linking this in causes some
1070 // side-effects:
1071 //
1072 // 1. For x86-32, it will set the x87 rounding mode to 53-bit instead of
1073 // 64-bit mantissas at program start.
1074 //
1075 // 2. It links in support routines for floating-point in scanf and printf.
1076 //
1077 // MSVC emits an undefined reference to _fltused when there are any
1078 // floating point operations in the program (including calls). A program
1079 // that only has: `scanf("%f", &global_float);` may fail to trigger this,
1080 // but oh well...that's a documented issue.
1081 StringRef SymbolName =
1082 (TT.getArch() == Triple::x86) ? "__fltused" : "_fltused";
1083 MCSymbol *S = MMI->getContext().getOrCreateSymbol(SymbolName);
1084 OutStreamer->emitSymbolAttribute(S, MCSA_Global);
1085 return;
1086 }
1087 } else if (TT.isOSBinFormatELF()) {
1088 FM.serializeToFaultMapSection();
1089 }
1090
1091 // Emit __morestack address if needed for indirect calls.
1092 if (TT.isX86_64() && TM.getCodeModel() == CodeModel::Large) {
1093 if (MCSymbol *AddrSymbol = OutContext.lookupSymbol("__morestack_addr")) {
1094 Align Alignment(1);
1097 /*C=*/nullptr, Alignment);
1098 OutStreamer->switchSection(ReadOnlySection);
1099 OutStreamer->emitLabel(AddrSymbol);
1100
1101 unsigned PtrSize = MAI->getCodePointerSize();
1102 OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("__morestack"),
1103 PtrSize);
1104 }
1105 }
1106}
1107
1108char X86AsmPrinter::ID = 0;
1109
1110 INITIALIZE_PASS(X86AsmPrinter, "x86-asm-printer", "X86 Assembly Printer", false,
1111 false)
1112
1113//===----------------------------------------------------------------------===//
1114// Target Registry Stuff
1115//===----------------------------------------------------------------------===//
1116
1117// Force static initialization.
1118extern "C" LLVM_C_ABI void LLVMInitializeX86AsmPrinter() {
1121}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static MCDisassembler::DecodeStatus addOperand(MCInst &Inst, const MCOperand &Opnd)
static void emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, MachineModuleInfoImpl::StubValueTy &MCSym)
MachineBasicBlock & MBB
Expand Atomic instructions
IRTranslator LLVM IR MI
Module.h This file contains the declarations for the Module class.
F
#define F(x, y, z)
Definition MD5.cpp:55
I
#define I(x, y, z)
Definition MD5.cpp:58
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
Register Reg
Promote Memory to Register
Definition Mem2Reg.cpp:110
P
#define P(N)
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition PassSupport.h:56
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
Definition Value.cpp:472
Y
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
X
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
#define LLVM_C_ABI
LLVM_C_ABI is the export/visibility macro used to mark symbols declared in llvm-c as exported when bu...
Definition Visibility.h:40
static bool printAsmMRegister(const X86AsmPrinter &P, const MachineOperand &MO, char Mode, raw_ostream &O)
static bool isSimpleReturn(const MachineInstr &MI)
static bool usesMSVCFloatingPoint(const Triple &TT, const Module &M)
True if this module is being built for windows/msvc, and uses floating point.
static bool isIndirectBranchOrTailCall(const MachineInstr &MI)
static bool printAsmVRegister(const MachineOperand &MO, char Mode, raw_ostream &O)
static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer)
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition AsmPrinter.cpp:431
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition AsmPrinter.cpp:725
void emitNops(unsigned N)
Emit N NOP instructions.
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition AsmPrinter.cpp:451
TargetMachine & TM
Target machine description.
Definition AsmPrinter.h:99
void emitXRayTable()
Emit a table with all XRay instrumentation points.
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
const MCAsmInfo * MAI
Target Asm Printer information.
Definition AsmPrinter.h:102
MachineFunction * MF
The current machine function.
Definition AsmPrinter.h:117
virtual const MCExpr * lowerConstant(const Constant *CV, const Constant *BaseCV=nullptr, uint64_t Offset=0)
Lower the specified LLVM Constant to an MCExpr.
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
void emitFunctionBody()
This method emits the body and trailer for a function.
virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const
This emits linkage information about GVSym based on GV, if this is supported by the target.
Definition AsmPrinter.cpp:680
AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer, char &ID=AsmPrinter::ID)
Definition AsmPrinter.cpp:407
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition AsmPrinter.cpp:729
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition AsmPrinter.h:136
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition AsmPrinter.h:120
void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr, unsigned MaxBytesToEmit=0) const
Emit an alignment directive to the specified power of two boundary.
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition AsmPrinter.h:106
const StaticDataProfileInfo * SDPI
Provides the profile information for constants.
Definition AsmPrinter.h:155
virtual const MCSubtargetInfo * getIFuncMCSubtargetInfo() const
getSubtargetInfo() cannot be used where this is needed because we don't have a MachineFunction when w...
Definition AsmPrinter.h:669
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition AsmPrinter.h:111
const ProfileSummaryInfo * PSI
The profile summary information.
Definition AsmPrinter.h:158
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
const DataLayout & getDataLayout() const
Return information about data layout.
Definition AsmPrinter.cpp:435
void emitCOFFFeatureSymbol(Module &M)
Emits the @feat.00 symbol indicating the features enabled in this module.
MCSymbol * GetExternalSymbolSymbol(const Twine &Sym) const
Return the MCSymbol for the specified ExternalSymbol.
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition AsmPrinter.cpp:446
void emitCOFFReplaceableFunctionData(Module &M)
Emits symbols and data to allow functions marked with the loader-replaceable attribute to be replacea...
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
This is the shared class of boolean and integer constants.
Definition Constants.h:87
const Constant * getResolver() const
Definition GlobalIFunc.h:73
bool hasInternalLinkage() const
Definition GlobalValue.h:528
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition MCExpr.h:428
LLVM_ABI MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition MCContext.cpp:540
LLVM_ABI MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition MCContext.cpp:203
Base class for the full range of assembler expressions which are needed for parsing.
Definition MCExpr.h:34
Instances of this class represent a single low-level machine instruction.
Definition MCInst.h:188
void setOpcode(unsigned Op)
Definition MCInst.h:201
static MCOperand createExpr(const MCExpr *Val)
Definition MCInst.h:166
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition MCSection.h:521
Streaming machine code generation interface.
Definition MCStreamer.h:220
virtual void addBlankLine()
Emit a blank line to a .s file to pretty it up.
Definition MCStreamer.h:408
virtual bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute)=0
Add the given Attribute to Symbol.
MCContext & getContext() const
Definition MCStreamer.h:314
void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc=SMLoc())
Definition MCStreamer.cpp:178
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition MCStreamer.cpp:395
virtual void emitIntValue(uint64_t Value, unsigned Size)
Special case of EmitValue that avoids the client having to pass in a MCExpr for constant integers.
Definition MCStreamer.cpp:132
virtual void switchSection(MCSection *Section, uint32_t Subsec=0)
Set the current section where code is being emitted to Section.
Generic base class for all target subtargets.
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:214
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
LLVM_ABI void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition MCSymbol.cpp:59
StringRef getName() const
getName - Get the symbol name.
Definition MCSymbol.h:188
Metadata node.
Definition Metadata.h:1078
Representation of each machine instruction.
Definition MachineInstr.h:72
LLVM_ABI InlineAsm::AsmDialect getInlineAsmDialect() const
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
PointerIntPair< MCSymbol *, 1, bool > StubValueTy
MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets.
SymbolListTy GetGVStubList()
Accessor methods to return the set of stubs in sorted order.
This class contains meta information specific to a module.
const MCContext & getContext() const
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
MachineOperand class - Representation of each machine instruction operand.
const GlobalValue * getGlobal() const
int64_t getImm() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
bool isSymbol() const
isSymbol - Tests if this is a MO_ExternalSymbol operand.
const BlockAddress * getBlockAddress() const
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
unsigned getTargetFlags() const
bool isGlobal() const
isGlobal - Tests if this is a MO_GlobalAddress operand.
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Register getReg() const
getReg - Returns the register number.
@ MO_Immediate
Immediate operand.
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
@ MO_GlobalAddress
Address of a global value.
@ MO_BlockAddress
Address of a basic block.
@ MO_Register
Register operand.
@ MO_ExternalSymbol
Name of external global symbol.
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
int64_t getOffset() const
Return the offset from the symbol in this operand.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:67
AnalysisType * getAnalysisIfAvailable() const
getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information tha...
IntType getInt() const
PointerTy getPointer() const
Wrapper class representing virtual and physical registers.
Definition Register.h:19
static SectionKind getMetadata()
Definition SectionKind.h:188
static SectionKind getReadOnly()
Definition SectionKind.h:192
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
constexpr bool empty() const
empty - Check if the string is empty.
Definition StringRef.h:143
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:637
virtual MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const
Given a constant with the SectionKind, return a section that it should be placed in.
Primary interface to the complete machine description for the target machine.
Definition TargetMachine.h:83
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
bool isX86_64() const
Tests whether the target is x86 (64-bit).
Definition Triple.h:1120
bool isOSWindows() const
Tests whether the OS is Windows.
Definition Triple.h:681
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
LLVM Value Representation.
Definition Value.h:75
static const char * getRegisterName(MCRegister Reg)
bool runOnMachineFunction(MachineFunction &MF) override
runOnMachineFunction - Emit the function body.
void emitKCFITypeId(const MachineFunction &MF) override
emitKCFITypeId - Emit the KCFI type information in architecture specific format.
void emitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
void emitFunctionBodyEnd() override
Targets can override this to emit stuff after the last basic block in the function.
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
void emitBasicBlockEnd(const MachineBasicBlock &MBB) override
Targets can override this to emit stuff at the end of a basic block.
X86AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &O) override
PrintAsmOperand - Print out an operand for an inline asm expression.
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-s...
X86 target streamer implementing x86-only assembly directives.
virtual bool emitFPOProc(const MCSymbol *ProcSym, unsigned ParamsSize, SMLoc L={})
virtual void emitCode16()
virtual bool emitFPOEndProc(SMLoc L={})
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_SYM_CLASS_EXTERNAL
External symbol.
Definition COFF.h:224
@ IMAGE_SYM_CLASS_STATIC
Static.
Definition COFF.h:225
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
Definition COFF.h:276
@ SCT_COMPLEX_TYPE_SHIFT
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
Definition COFF.h:280
@ NT_GNU_PROPERTY_TYPE_0
Definition ELF.h:1809
@ SHF_ALLOC
Definition ELF.h:1248
@ SHT_NOTE
Definition ELF.h:1153
@ GNU_PROPERTY_X86_FEATURE_1_AND
Definition ELF.h:1844
@ GNU_PROPERTY_X86_FEATURE_1_SHSTK
Definition ELF.h:1891
@ GNU_PROPERTY_X86_FEATURE_1_IBT
Definition ELF.h:1890
@ S_NON_LAZY_SYMBOL_POINTERS
S_NON_LAZY_SYMBOL_POINTERS - Section with non-lazy symbol pointers.
Definition MachO.h:139
@ MO_TLSLD
MO_TLSLD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition X86BaseInfo.h:411
@ MO_GOTPCREL_NORELAX
MO_GOTPCREL_NORELAX - Same as MO_GOTPCREL except that R_X86_64_GOTPCREL relocations are guaranteed to...
Definition X86BaseInfo.h:391
@ MO_GOTOFF
MO_GOTOFF - On a symbol operand this indicates that the immediate is the offset to the location of th...
Definition X86BaseInfo.h:381
@ MO_DARWIN_NONLAZY_PIC_BASE
MO_DARWIN_NONLAZY_PIC_BASE - On a symbol operand "FOO", this indicates that the reference is actually...
Definition X86BaseInfo.h:468
@ MO_GOT_ABSOLUTE_ADDRESS
MO_GOT_ABSOLUTE_ADDRESS - On a symbol operand, this represents a relocation of: SYMBOL_LABEL + [.
Definition X86BaseInfo.h:367
@ MO_COFFSTUB
MO_COFFSTUB - On a symbol operand "FOO", this indicates that the reference is actually to the "....
Definition X86BaseInfo.h:488
@ MO_NTPOFF
MO_NTPOFF - On a symbol operand this indicates that the immediate is the negative thread-pointer offs...
Definition X86BaseInfo.h:450
@ MO_DARWIN_NONLAZY
MO_DARWIN_NONLAZY - On a symbol operand "FOO", this indicates that the reference is actually to the "...
Definition X86BaseInfo.h:464
@ MO_INDNTPOFF
MO_INDNTPOFF - On a symbol operand this indicates that the immediate is the absolute address of the G...
Definition X86BaseInfo.h:432
@ MO_GOTNTPOFF
MO_GOTNTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry w...
Definition X86BaseInfo.h:456
@ MO_TPOFF
MO_TPOFF - On a symbol operand this indicates that the immediate is the thread-pointer offset for the...
Definition X86BaseInfo.h:438
@ MO_TLVP_PIC_BASE
MO_TLVP_PIC_BASE - On a symbol operand this indicates that the immediate is some TLS offset from the ...
Definition X86BaseInfo.h:476
@ MO_GOT
MO_GOT - On a symbol operand this indicates that the immediate is the offset to the GOT entry for the...
Definition X86BaseInfo.h:376
@ MO_PLT
MO_PLT - On a symbol operand this indicates that the immediate is offset to the PLT entry of symbol n...
Definition X86BaseInfo.h:396
@ MO_TLSGD
MO_TLSGD - On a symbol operand this indicates that the immediate is the offset of the GOT entry with ...
Definition X86BaseInfo.h:403
@ MO_NO_FLAG
MO_NO_FLAG - No flag for the operand.
Definition X86BaseInfo.h:363
@ MO_TLVP
MO_TLVP - On a symbol operand this indicates that the immediate is some TLS offset.
Definition X86BaseInfo.h:472
@ MO_DLLIMPORT
MO_DLLIMPORT - On a symbol operand "FOO", this indicates that the reference is actually to the "__imp...
Definition X86BaseInfo.h:460
@ MO_GOTTPOFF
MO_GOTTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry wi...
Definition X86BaseInfo.h:425
@ MO_SECREL
MO_SECREL - On a symbol operand this indicates that the immediate is the offset from beginning of sec...
Definition X86BaseInfo.h:480
@ MO_DTPOFF
MO_DTPOFF - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition X86BaseInfo.h:444
@ MO_PIC_BASE_OFFSET
MO_PIC_BASE_OFFSET - On a symbol operand this indicates that the immediate should get the value of th...
Definition X86BaseInfo.h:371
@ MO_TLSLDM
MO_TLSLDM - On a symbol operand this indicates that the immediate is the offset of the GOT entry with...
Definition X86BaseInfo.h:419
@ MO_GOTPCREL
MO_GOTPCREL - On a symbol operand this indicates that the immediate is offset to the GOT entry for th...
Definition X86BaseInfo.h:387
@ AddrBaseReg
Definition X86BaseInfo.h:29
@ AddrScaleAmt
Definition X86BaseInfo.h:30
@ AddrSegmentReg
Definition X86BaseInfo.h:34
@ AddrIndexReg
Definition X86BaseInfo.h:31
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
Definition Metadata.h:667
BaseReg
Stack frame base register. Bit 0 of FREInfo.Info.
Definition SFrame.h:77
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
FunctionAddr VTableAddr Value
Definition InstrProf.h:137
static bool isMem(const MachineInstr &MI, unsigned Op)
Definition X86InstrInfo.h:170
MCRegister getX86SubSuperRegister(MCRegister Reg, unsigned Size, bool High=false)
Target & getTheX86_32Target()
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition Alignment.h:186
DWARFExpression::Operation Op
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1867
Target & getTheX86_64Target()
@ MCSA_IndirectSymbol
.indirect_symbol (MachO)
Definition MCDirectives.h:35
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition MCDirectives.h:30
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition MCDirectives.h:23
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:867
N
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /