85#define DEBUG_TYPE "asmprinter"
87STATISTIC(NumTOCEntries,
"Number of Total TOC Entries Emitted.");
88STATISTIC(NumTOCConstPool,
"Number of Constant Pool TOC Entries.");
90 "Number of Internal Linkage Global TOC Entries.");
92 "Number of External Linkage Global TOC Entries.");
93STATISTIC(NumTOCJumpTable,
"Number of Jump Table TOC Entries.");
94STATISTIC(NumTOCThreadLocal,
"Number of Thread Local TOC Entries.");
95STATISTIC(NumTOCBlockAddress,
"Number of Block Address TOC Entries.");
96STATISTIC(NumTOCEHBlock,
"Number of EH Block TOC Entries.");
109 using TOCKey = std::pair<const MCSymbol *, MCSymbolRefExpr::VariantKind>;
130 Tag_GNU_Power_ABI_FP = 4,
131 Tag_GNU_Power_ABI_Vector = 8,
132 Tag_GNU_Power_ABI_Struct_Return = 12,
135 Val_GNU_Power_ABI_NoFloat = 0b00,
136 Val_GNU_Power_ABI_HardFloat_DP = 0b01,
137 Val_GNU_Power_ABI_SoftFloat_DP = 0b10,
138 Val_GNU_Power_ABI_HardFloat_SP = 0b11,
140 Val_GNU_Power_ABI_LDBL_IBM128 = 0b0100,
141 Val_GNU_Power_ABI_LDBL_64 = 0b1000,
142 Val_GNU_Power_ABI_LDBL_IEEE128 = 0b1100,
166 std::unique_ptr<MCStreamer> Streamer)
172 TOCType_ConstantPool,
173 TOCType_GlobalExternal,
174 TOCType_GlobalInternal,
177 TOCType_BlockAddress,
183 MCSymbolRefExpr::VariantKind::VK_None);
219class PPCLinuxAsmPrinter :
public PPCAsmPrinter {
222 std::unique_ptr<MCStreamer> Streamer)
223 : PPCAsmPrinter(
TM,
std::
move(Streamer)) {}
226 return "Linux PPC Assembly Printer";
229 void emitGNUAttributes(
Module &M);
231 void emitStartOfAsmFile(
Module &M)
override;
232 void emitEndOfAsmFile(
Module &)
override;
234 void emitFunctionEntryLabel()
override;
236 void emitFunctionBodyStart()
override;
237 void emitFunctionBodyEnd()
override;
241class PPCAIXAsmPrinter :
public PPCAsmPrinter {
249 std::string FormatIndicatorAndUniqueModId;
257 void emitTracebackTable();
267 PPCAIXAsmPrinter(
TargetMachine &
TM, std::unique_ptr<MCStreamer> Streamer)
268 : PPCAsmPrinter(
TM,
std::
move(Streamer)) {
269 if (MAI->isLittleEndian())
271 "cannot create AIX PPC Assembly Printer for a little-endian target");
274 StringRef getPassName()
const override {
return "AIX PPC Assembly Printer"; }
276 bool doInitialization(
Module &M)
override;
279 bool IsCtor)
override;
285 void emitFunctionDescriptor()
override;
287 void emitFunctionEntryLabel()
override;
289 void emitFunctionBodyEnd()
override;
291 void emitPGORefs(
Module &M);
293 void emitEndOfAsmFile(
Module &)
override;
299 bool doFinalization(
Module &M)
override;
301 void emitTTypeReference(
const GlobalValue *GV,
unsigned Encoding)
override;
303 void emitModuleCommandLines(
Module &M)
override;
312 getSymbol(GV)->
print(O, MAI);
316void PPCAsmPrinter::printOperand(
const MachineInstr *
MI,
unsigned OpNo,
339 O <<
DL.getPrivateGlobalPrefix() <<
"CPI" << getFunctionNumber() <<
'_'
346 PrintSymbolOperand(MO, O);
358bool PPCAsmPrinter::PrintAsmOperand(
const MachineInstr *
MI,
unsigned OpNo,
361 if (ExtraCode && ExtraCode[0]) {
362 if (ExtraCode[1] != 0)
return true;
364 switch (ExtraCode[0]) {
370 if (!
MI->getOperand(OpNo).isReg() ||
371 OpNo+1 ==
MI->getNumOperands() ||
372 !
MI->getOperand(OpNo+1).isReg())
379 if (
MI->getOperand(OpNo).isImm())
383 if(!
MI->getOperand(OpNo).isReg())
389 Reg = PPC::VSX32 + (
Reg - PPC::V0);
391 Reg = PPC::VSX32 + (Reg - PPC::VF0);
407bool PPCAsmPrinter::PrintAsmMemoryOperand(
const MachineInstr *
MI,
unsigned OpNo,
408 const char *ExtraCode,
410 if (ExtraCode && ExtraCode[0]) {
411 if (ExtraCode[1] != 0)
return true;
413 switch (ExtraCode[0]) {
414 default:
return true;
416 O << getDataLayout().getPointerSize() <<
"(";
427 if (
MI->getOperand(OpNo).isImm())
438 assert(
MI->getOperand(OpNo).isReg());
443 assert(
MI->getOperand(OpNo).isReg());
453 case PPCAsmPrinter::TOCType_ConstantPool:
456 case PPCAsmPrinter::TOCType_GlobalInternal:
457 ++NumTOCGlobalInternal;
459 case PPCAsmPrinter::TOCType_GlobalExternal:
460 ++NumTOCGlobalExternal;
462 case PPCAsmPrinter::TOCType_JumpTable:
465 case PPCAsmPrinter::TOCType_ThreadLocal:
468 case PPCAsmPrinter::TOCType_BlockAddress:
469 ++NumTOCBlockAddress;
471 case PPCAsmPrinter::TOCType_EHBlock:
488 assert(GV &&
"expected global for MO_GlobalAddress");
510PPCAsmPrinter::lookUpOrCreateTOCEntry(
const MCSymbol *
Sym, TOCEntryType
Type,
513 if (!
TOC.contains({Sym, Kind}))
518 TOCEntry = createTempSymbol(
"C");
523 unsigned NumNOPBytes =
MI.getOperand(1).getImm();
525 auto &Ctx = OutStreamer->getContext();
526 MCSymbol *MILabel = Ctx.createTempSymbol();
527 OutStreamer->emitLabel(MILabel);
530 assert(NumNOPBytes % 4 == 0 &&
"Invalid number of NOP bytes requested!");
536 while (NumNOPBytes > 0) {
537 if (MII ==
MBB.
end() || MII->isCall() ||
538 MII->getOpcode() == PPC::DBG_VALUE ||
539 MII->getOpcode() == TargetOpcode::PATCHPOINT ||
540 MII->getOpcode() == TargetOpcode::STACKMAP)
547 for (
unsigned i = 0; i < NumNOPBytes; i += 4)
554 auto &Ctx = OutStreamer->getContext();
555 MCSymbol *MILabel = Ctx.createTempSymbol();
556 OutStreamer->emitLabel(MILabel);
561 unsigned EncodedBytes = 0;
564 if (CalleeMO.
isImm()) {
565 int64_t CallTarget = CalleeMO.
getImm();
567 assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
568 "High 16 bits of call target should be zero.");
569 Register ScratchReg =
MI.getOperand(Opers.getNextScratchIdx()).getReg();
574 .addImm((CallTarget >> 32) & 0xFFFF));
579 .addImm(32).addImm(16));
584 .addImm((CallTarget >> 16) & 0xFFFF));
589 .addImm(CallTarget & 0xFFFF));
595 .addImm(TOCSaveOffset)
608 .addReg(ScratchReg));
613 .addReg(ScratchReg));
618 .addReg(ScratchReg));
626 .addImm(TOCSaveOffset)
632 MCSymbol *MOSymbol = getSymbol(GValue);
644 unsigned NumBytes = Opers.getNumPatchBytes();
645 assert(NumBytes >= EncodedBytes &&
646 "Patchpoint can't request size less than the length of a call.");
647 assert((NumBytes - EncodedBytes) % 4 == 0 &&
648 "Invalid number of NOP bytes requested!");
649 for (
unsigned i = EncodedBytes; i < NumBytes; i += 4)
660 SymName =
".__tls_get_addr";
662 case PPC::GETtlsTpointer32AIX:
663 SymName =
".__get_tpointer";
665 case PPC::GETtlsMOD32AIX:
666 case PPC::GETtlsMOD64AIX:
667 SymName =
".__tls_get_mod";
678 "Only expecting to emit calls to get the thread pointer on AIX!");
683 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BLA).addExpr(TlsRef));
691 unsigned Opcode = PPC::BL8_NOP_TLS;
693 assert(
MI->getNumOperands() >= 3 &&
"Expecting at least 3 operands from MI");
697 Opcode = PPC::BL8_NOTOC_TLS;
699 const Module *
M = MF->getFunction().getParent();
702 ((Subtarget->
isPPC64() &&
MI->getOperand(0).getReg() == PPC::X3) ||
703 (!Subtarget->
isPPC64() &&
MI->getOperand(0).getReg() == PPC::R3)) &&
704 "GETtls[ld]ADDR[32] must define GPR3");
706 ((Subtarget->
isPPC64() &&
MI->getOperand(1).getReg() == PPC::X3) ||
707 (!Subtarget->
isPPC64() &&
MI->getOperand(1).getReg() == PPC::R3)) &&
708 "GETtls[ld]ADDR[32] must read GPR3");
717 assert((
MI->getOpcode() == PPC::GETtlsMOD32AIX ||
718 MI->getOpcode() == PPC::GETtlsMOD64AIX ||
719 (
MI->getOperand(2).isReg() &&
720 MI->getOperand(2).getReg() == VarOffsetReg)) &&
721 "GETtls[ld]ADDR[32] must read GPR4");
722 EmitAIXTlsCallHelper(
MI);
726 MCSymbol *TlsGetAddr = OutContext.getOrCreateSymbol(
"__tls_get_addr");
741 MCSymbol *MOSymbol = getSymbol(GValue);
743 EmitToStreamer(*OutStreamer,
745 : (
unsigned)PPC::BL_TLS)
768static PPCAsmPrinter::TOCEntryType
773 return PPCAsmPrinter::TOCType_ThreadLocal;
782 return PPCAsmPrinter::TOCType_GlobalExternal;
784 return PPCAsmPrinter::TOCType_GlobalInternal;
787 return PPCAsmPrinter::TOCType_ConstantPool;
789 return PPCAsmPrinter::TOCType_JumpTable;
791 return PPCAsmPrinter::TOCType_BlockAddress;
800 PPC_MC::verifyInstructionPredicates(
MI->getOpcode(),
801 getSubtargetInfo().getFeatureBits());
804 const bool IsPPC64 = Subtarget->
isPPC64();
805 const bool IsAIX = Subtarget->
isAIXABI();
806 const bool HasAIXSmallLocalTLS = Subtarget->hasAIXSmallLocalExecTLS() ||
807 Subtarget->hasAIXSmallLocalDynamicTLS();
808 const Module *
M = MF->getFunction().getParent();
813 if (!
MI->isInlineAsm()) {
817 if (Subtarget->hasSPE()) {
818 if (PPC::F4RCRegClass.
contains(Reg) ||
827 if (PPC::SPERCRegClass.
contains(Reg))
835 auto getTOCRelocAdjustedExprForXCOFF = [
this](
const MCExpr *Expr,
844 OriginalOffset - llvm::SignExtend32<16>(OriginalOffset);
849 auto getTOCEntryLoadingExprForXCOFF =
850 [IsPPC64, getTOCRelocAdjustedExprForXCOFF,
853 MCSymbolRefExpr::VariantKind::VK_None) ->
const MCExpr * {
854 const unsigned EntryByteSize = IsPPC64 ? 8 : 4;
855 const auto TOCEntryIter =
TOC.find({MOSymbol, VK});
857 "Could not find the TOC entry for this symbol.");
858 const ptrdiff_t EntryDistanceFromTOCBase =
859 (TOCEntryIter -
TOC.begin()) * EntryByteSize;
860 constexpr int16_t PositiveTOCRange = INT16_MAX;
862 if (EntryDistanceFromTOCBase > PositiveTOCRange)
863 return getTOCRelocAdjustedExprForXCOFF(Expr, EntryDistanceFromTOCBase);
875 assert(MO.
isGlobal() &&
"Only expecting a global MachineOperand here!\n");
878 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSLE;
880 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSIE;
887 dbgs() <<
"Current function uses IE access for default LD vars.\n");
888 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSIE;
896 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM;
898 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGD;
903 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSLD;
905 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSML;
906 return MCSymbolRefExpr::VariantKind::VK_None;
910 switch (
MI->getOpcode()) {
912 case TargetOpcode::DBG_VALUE:
914 case TargetOpcode::STACKMAP:
915 return LowerSTACKMAP(SM, *
MI);
916 case TargetOpcode::PATCHPOINT:
917 return LowerPATCHPOINT(SM, *
MI);
919 case PPC::MoveGOTtoLR: {
927 OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
936 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BL).addExpr(OffsExpr));
939 case PPC::MovePCtoLR:
940 case PPC::MovePCtoLR8: {
945 MCSymbol *PICBase = MF->getPICBaseSymbol();
948 EmitToStreamer(*OutStreamer,
955 OutStreamer->emitLabel(PICBase);
958 case PPC::UpdateGBR: {
967 if (Subtarget->isSecurePlt() && isPositionIndependent() ) {
969 MCSymbol *BaseSymbol = OutContext.getOrCreateSymbol(
981 MCInstBuilder(PPC::ADDIS).addReg(PICR).addReg(PICR).addExpr(DeltaHi));
986 MCInstBuilder(PPC::ADDI).addReg(PICR).addReg(PICR).addExpr(DeltaLo));
1006 EmitToStreamer(*OutStreamer, TmpInst);
1012 EmitToStreamer(*OutStreamer, TmpInst);
1025 "Invalid operand for LWZtoc.");
1037 EmitToStreamer(*OutStreamer, TmpInst);
1057 "This pseudo should only be selected for 32-bit small code model.");
1058 Exp = getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK);
1063 OutStreamer->getCommentOS() << MO <<
'\n';
1064 EmitToStreamer(*OutStreamer, TmpInst);
1071 OutContext.getOrCreateSymbol(
Twine(
".LTOC")), OutContext);
1074 EmitToStreamer(*OutStreamer, TmpInst);
1078 case PPC::ADDItoc8: {
1080 "PseudoOp only valid for small code model AIX");
1086 TmpInst.
setOpcode((!IsPPC64) ? (PPC::LA) : (PPC::LA8));
1099 EmitToStreamer(*OutStreamer, TmpInst);
1114 "Invalid operand!");
1131 IsAIX ? getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK) : Exp);
1134 if (isVerbose() && IsAIX)
1135 OutStreamer->getCommentOS() << MO <<
'\n';
1136 EmitToStreamer(*OutStreamer, TmpInst);
1139 case PPC::ADDIStocHA: {
1143 "Invalid operand for ADDIStocHA.");
1144 assert((IsAIX && !IsPPC64 &&
1146 "This pseudo should only be selected for 32-bit large code model on"
1174 return GV->hasAttribute(
"toc-data");
1182 EmitToStreamer(*OutStreamer, TmpInst);
1185 case PPC::LWZtocL: {
1189 "Invalid operand for LWZtocL.");
1190 assert(IsAIX && !IsPPC64 &&
1192 "This pseudo should only be selected for 32-bit large code model on"
1216 EmitToStreamer(*OutStreamer, TmpInst);
1219 case PPC::ADDIStocHA8: {
1231 "Invalid operand for ADDIStocHA8!");
1237 const bool GlobalToc =
1259 EmitToStreamer(*OutStreamer, TmpInst);
1275 "Invalid operand for LDtocL!");
1279 "LDtocL used on symbol that could be accessed directly is "
1280 "invalid. Must match ADDIStocHA8."));
1294 EmitToStreamer(*OutStreamer, TmpInst);
1298 case PPC::ADDItocL8: {
1302 unsigned Op =
MI->getOpcode();
1305 TmpInst.
setOpcode(
Op == PPC::ADDItocL8 ? PPC::ADDI8 : PPC::LA);
1310 : MO.
isGlobal() &&
"Invalid operand for ADDItocL8.");
1312 "Interposable definitions must use indirect accesses.");
1324 EmitToStreamer(*OutStreamer, TmpInst);
1327 case PPC::ADDISgotTprelHA: {
1330 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1333 MCSymbol *MOSymbol = getSymbol(GValue);
1334 const MCExpr *SymGotTprel =
1338 .addReg(
MI->getOperand(0).getReg())
1339 .
addReg(
MI->getOperand(1).getReg())
1343 case PPC::LDgotTprelL:
1344 case PPC::LDgotTprelL32: {
1349 TmpInst.
setOpcode(IsPPC64 ? PPC::LD : PPC::LWZ);
1352 MCSymbol *MOSymbol = getSymbol(GValue);
1358 EmitToStreamer(*OutStreamer, TmpInst);
1362 case PPC::PPC32PICGOT: {
1363 MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
1364 MCSymbol *GOTRef = OutContext.createTempSymbol();
1365 MCSymbol *NextInstr = OutContext.createTempSymbol();
1375 OutStreamer->emitLabel(GOTRef);
1376 OutStreamer->emitValue(OffsExpr, 4);
1377 OutStreamer->emitLabel(NextInstr);
1379 .addReg(
MI->getOperand(0).getReg()));
1381 .addReg(
MI->getOperand(1).getReg())
1383 .
addReg(
MI->getOperand(0).getReg()));
1385 .addReg(
MI->getOperand(0).getReg())
1386 .
addReg(
MI->getOperand(1).getReg())
1387 .
addReg(
MI->getOperand(0).getReg()));
1390 case PPC::PPC32GOT: {
1392 OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
1398 .addReg(
MI->getOperand(0).getReg())
1401 .addReg(
MI->getOperand(0).getReg())
1402 .
addReg(
MI->getOperand(0).getReg())
1406 case PPC::ADDIStlsgdHA: {
1409 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1412 MCSymbol *MOSymbol = getSymbol(GValue);
1413 const MCExpr *SymGotTlsGD =
1417 .addReg(
MI->getOperand(0).getReg())
1418 .
addReg(
MI->getOperand(1).getReg())
1422 case PPC::ADDItlsgdL:
1425 case PPC::ADDItlsgdL32: {
1430 MCSymbol *MOSymbol = getSymbol(GValue);
1435 EmitToStreamer(*OutStreamer,
1437 .addReg(
MI->getOperand(0).getReg())
1438 .
addReg(
MI->getOperand(1).getReg())
1442 case PPC::GETtlsMOD32AIX:
1443 case PPC::GETtlsMOD64AIX:
1447 case PPC::GETtlsADDR:
1450 case PPC::GETtlsADDRPCREL:
1451 case PPC::GETtlsADDR32AIX:
1452 case PPC::GETtlsADDR64AIX:
1456 case PPC::GETtlsADDR32: {
1462 case PPC::GETtlsTpointer32AIX: {
1465 EmitAIXTlsCallHelper(
MI);
1468 case PPC::ADDIStlsldHA: {
1471 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1474 MCSymbol *MOSymbol = getSymbol(GValue);
1475 const MCExpr *SymGotTlsLD =
1479 .addReg(
MI->getOperand(0).getReg())
1480 .
addReg(
MI->getOperand(1).getReg())
1484 case PPC::ADDItlsldL:
1487 case PPC::ADDItlsldL32: {
1492 MCSymbol *MOSymbol = getSymbol(GValue);
1497 EmitToStreamer(*OutStreamer,
1499 .addReg(
MI->getOperand(0).getReg())
1500 .
addReg(
MI->getOperand(1).getReg())
1504 case PPC::GETtlsldADDR:
1507 case PPC::GETtlsldADDRPCREL:
1508 case PPC::GETtlsldADDR32: {
1514 case PPC::ADDISdtprelHA:
1517 case PPC::ADDISdtprelHA32: {
1522 MCSymbol *MOSymbol = getSymbol(GValue);
1523 const MCExpr *SymDtprel =
1529 .addReg(
MI->getOperand(0).getReg())
1530 .
addReg(
MI->getOperand(1).getReg())
1534 case PPC::PADDIdtprel: {
1539 MCSymbol *MOSymbol = getSymbol(GValue);
1543 .addReg(
MI->getOperand(0).getReg())
1544 .
addReg(
MI->getOperand(1).getReg())
1549 case PPC::ADDIdtprelL:
1552 case PPC::ADDIdtprelL32: {
1557 MCSymbol *MOSymbol = getSymbol(GValue);
1558 const MCExpr *SymDtprel =
1561 EmitToStreamer(*OutStreamer,
1563 .addReg(
MI->getOperand(0).getReg())
1564 .
addReg(
MI->getOperand(1).getReg())
1570 if (!Subtarget->hasMFOCRF()) {
1573 unsigned NewOpcode =
1574 MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
1578 .addReg(
MI->getOperand(0).getReg()));
1584 if (!Subtarget->hasMFOCRF()) {
1587 unsigned NewOpcode =
1588 MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
1589 unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
1590 ->getEncodingValue(
MI->getOperand(0).getReg());
1595 .addReg(
MI->getOperand(1).getReg()));
1605 unsigned OpNum = (
MI->getOpcode() == PPC::STD) ? 2 : 1;
1612 TempMO.getOperandNo() == 1)
1649 if (!HasAIXSmallLocalTLS)
1651 bool IsMIADDI8 =
MI->getOpcode() == PPC::ADDI8;
1652 unsigned OpNum = IsMIADDI8 ? 2 : 1;
1668 EmitToStreamer(*OutStreamer, TmpInst);
1674 case PPC::PseudoEIEIO: {
1677 MCInstBuilder(PPC::ORI).addReg(PPC::X2).addReg(PPC::X2).addImm(0));
1680 MCInstBuilder(PPC::ORI).addReg(PPC::X2).addReg(PPC::X2).addImm(0));
1681 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::EnforceIEIO));
1687 EmitToStreamer(*OutStreamer, TmpInst);
1697PPCAsmPrinter::getAdjustedFasterLocalExpr(
const MachineOperand &MO,
1704 assert(MO.
isGlobal() &&
"Only expecting a global MachineOperand here!");
1708 "Only local-[exec|dynamic] accesses are handled!");
1714 const auto TLSVarsMapEntryIter = TLSVarsToAddressMapping.
find(GValue);
1715 if (TLSVarsMapEntryIter == TLSVarsToAddressMapping.
end())
1716 assert(IsGlobalADeclaration &&
1717 "Only expecting to find extern TLS variables not present in the TLS "
1718 "variable-to-address map!");
1720 unsigned TLSVarAddress =
1721 IsGlobalADeclaration ? 0 : TLSVarsMapEntryIter->second;
1735 if (FinalAddress >= 32768) {
1742 ptrdiff_t Delta = ((FinalAddress + 32768) & ~0xFFFF);
1746 ((InstDisp < 32768) && (InstDisp >= -32768)) &&
1747 "Expecting the instruction displacement for local-[exec|dynamic] TLS "
1748 "variables to be between [-32768, 32768)!");
1756void PPCLinuxAsmPrinter::emitGNUAttributes(
Module &M) {
1758 Metadata *MD =
M.getModuleFlag(
"float-abi");
1759 MDString *FloatABI = dyn_cast_or_null<MDString>(MD);
1764 if (flt ==
"doubledouble")
1765 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1766 Val_GNU_Power_ABI_HardFloat_DP |
1767 Val_GNU_Power_ABI_LDBL_IBM128);
1768 else if (flt ==
"ieeequad")
1769 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1770 Val_GNU_Power_ABI_HardFloat_DP |
1771 Val_GNU_Power_ABI_LDBL_IEEE128);
1772 else if (flt ==
"ieeedouble")
1773 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1774 Val_GNU_Power_ABI_HardFloat_DP |
1775 Val_GNU_Power_ABI_LDBL_64);
1778void PPCLinuxAsmPrinter::emitInstruction(
const MachineInstr *
MI) {
1780 return PPCAsmPrinter::emitInstruction(
MI);
1782 switch (
MI->getOpcode()) {
1784 return PPCAsmPrinter::emitInstruction(
MI);
1785 case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
1797 MCSymbol *BeginOfSled = OutContext.createTempSymbol();
1798 MCSymbol *EndOfSled = OutContext.createTempSymbol();
1799 OutStreamer->emitLabel(BeginOfSled);
1800 EmitToStreamer(*OutStreamer,
1806 MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
1807 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
1808 EmitToStreamer(*OutStreamer,
1811 OutContext.getOrCreateSymbol(
"__xray_FunctionEntry"),
1813 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
1814 OutStreamer->emitLabel(EndOfSled);
1815 recordSled(BeginOfSled, *
MI, SledKind::FUNCTION_ENTER, 2);
1818 case TargetOpcode::PATCHABLE_RET: {
1819 unsigned RetOpcode =
MI->getOperand(0).getImm();
1829 if (RetOpcode == PPC::BCCLR) {
1830 IsConditional =
true;
1831 }
else if (RetOpcode == PPC::TCRETURNdi8 || RetOpcode == PPC::TCRETURNri8 ||
1832 RetOpcode == PPC::TCRETURNai8) {
1834 }
else if (RetOpcode == PPC::BLR8 || RetOpcode == PPC::TAILB8) {
1835 IsConditional =
false;
1837 EmitToStreamer(*OutStreamer, RetInst);
1842 if (IsConditional) {
1861 FallthroughLabel = OutContext.createTempSymbol();
1867 .
addReg(
MI->getOperand(2).getReg())
1884 OutStreamer->emitCodeAlignment(
Align(8), &getSubtargetInfo());
1885 MCSymbol *BeginOfSled = OutContext.createTempSymbol();
1886 OutStreamer->emitLabel(BeginOfSled);
1887 EmitToStreamer(*OutStreamer, RetInst);
1891 MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
1892 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
1893 EmitToStreamer(*OutStreamer,
1896 OutContext.getOrCreateSymbol(
"__xray_FunctionExit"),
1898 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
1899 EmitToStreamer(*OutStreamer, RetInst);
1901 OutStreamer->emitLabel(FallthroughLabel);
1902 recordSled(BeginOfSled, *
MI, SledKind::FUNCTION_EXIT, 2);
1905 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
1907 case TargetOpcode::PATCHABLE_TAIL_CALL:
1911 "around this assert.");
1915void PPCLinuxAsmPrinter::emitStartOfAsmFile(
Module &M) {
1923 !isPositionIndependent())
1929 OutStreamer->switchSection(OutContext.getELFSection(
1932 MCSymbol *TOCSym = OutContext.getOrCreateSymbol(
Twine(
".LTOC"));
1933 MCSymbol *CurrentPos = OutContext.createTempSymbol();
1935 OutStreamer->emitLabel(CurrentPos);
1944 OutStreamer->emitAssignment(TOCSym, tocExpr);
1946 OutStreamer->switchSection(getObjFileLowering().getTextSection());
1949void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
1952 (!isPositionIndependent() ||
1958 if (PPCFI->
usesPICBase() && !Subtarget->isSecurePlt()) {
1960 MCSymbol *PICBase = MF->getPICBaseSymbol();
1961 OutStreamer->emitLabel(RelocSymbol);
1969 OutStreamer->emitValue(OffsExpr, 4);
1970 OutStreamer->emitLabel(CurrentFnSym);
1983 && !MF->getRegInfo().use_empty(PPC::X2)) {
1988 const MCExpr *TOCDeltaExpr =
1995 OutStreamer->emitValue(TOCDeltaExpr, 8);
2004 OutStreamer->switchSection(Section);
2005 OutStreamer->emitLabel(CurrentFnSym);
2006 OutStreamer->emitValueToAlignment(
Align(8));
2007 MCSymbol *Symbol1 = CurrentFnSymForSize;
2014 OutStreamer->emitValue(
2018 OutStreamer->emitIntValue(0, 8 );
2019 OutStreamer->switchSection(Current.first, Current.second);
2022void PPCLinuxAsmPrinter::emitEndOfAsmFile(
Module &M) {
2025 bool isPPC64 =
DL.getPointerSizeInBits() == 64;
2035 OutStreamer->emitSymbolValue(
2036 GetExternalSymbolSymbol(
"__parse_hwcap_and_convert_at_platform"),
2037 MAI->getCodePointerSize());
2038 emitGNUAttributes(M);
2041 const char *
Name = isPPC64 ?
".toc" :
".got2";
2044 OutStreamer->switchSection(Section);
2046 OutStreamer->emitValueToAlignment(
Align(4));
2048 for (
const auto &TOCMapPair : TOC) {
2049 const MCSymbol *
const TOCEntryTarget = TOCMapPair.first.first;
2050 MCSymbol *
const TOCEntryLabel = TOCMapPair.second;
2052 OutStreamer->emitLabel(TOCEntryLabel);
2054 TS->
emitTCEntry(*TOCEntryTarget, TOCMapPair.first.second);
2056 OutStreamer->emitSymbolValue(TOCEntryTarget, 4);
2060 PPCAsmPrinter::emitEndOfAsmFile(M);
2064void PPCLinuxAsmPrinter::emitFunctionBodyStart() {
2097 const bool UsesX2OrR2 = !MF->getRegInfo().use_empty(PPC::X2) ||
2098 !MF->getRegInfo().use_empty(PPC::R2);
2107 if (NonPCrelGEPRequired || PCrelGEPRequired) {
2112 OutStreamer->emitLabel(GlobalEntryLabel);
2118 const MCExpr *TOCDeltaExpr =
2120 GlobalEntryLabelExp, OutContext);
2126 .addExpr(TOCDeltaHi));
2132 .addExpr(TOCDeltaLo));
2135 const MCExpr *TOCOffsetDeltaExpr =
2137 GlobalEntryLabelExp, OutContext);
2141 .addExpr(TOCOffsetDeltaExpr)
2150 OutStreamer->emitLabel(LocalEntryLabel);
2153 const MCExpr *LocalOffsetExp =
2155 GlobalEntryLabelExp, OutContext);
2159 TS->
emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
2182 if (MF->getFrameInfo().hasCalls() || MF->getFrameInfo().hasTailCall() ||
2183 MF->hasInlineAsm() || (!PPCFI->
usesTOCBasePtr() && UsesX2OrR2)) {
2195void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
2204 OutStreamer->emitIntValue(0, 4);
2205 OutStreamer->emitIntValue(0, 8);
2209void PPCAIXAsmPrinter::emitLinkage(
const GlobalValue *GV,
2212 assert(MAI->hasVisibilityOnlyWithLinkage() &&
2213 "AIX's linkage directives take a visibility setting.");
2234 "InternalLinkage should not have other visibility setting.");
2246 if (!
TM.getIgnoreXCOFFVisibility()) {
2249 "Cannot not be both dllexport and non-default visibility");
2255 VisibilityAttr = MAI->getExportedVisibilityAttr();
2258 VisibilityAttr = MAI->getHiddenVisibilityAttr();
2261 VisibilityAttr = MAI->getProtectedVisibilityAttr();
2271 OutStreamer->emitXCOFFSymbolLinkageWithVisibility(GVSym, LinkageAttr,
2278 cast<MCSectionXCOFF>(getObjFileLowering().getSectionForFunctionDescriptor(
2287uint16_t PPCAIXAsmPrinter::getNumberOfVRSaved() {
2292 if (Subtarget.
isAIXABI() && Subtarget.hasAltivec() &&
2293 TM.getAIXExtendedAltivecABI()) {
2295 for (
unsigned Reg = PPC::V20;
Reg <= PPC::V31; ++
Reg)
2296 if (
MRI.isPhysRegModified(Reg))
2298 return PPC::V31 - Reg + 1;
2303void PPCAIXAsmPrinter::emitFunctionBodyEnd() {
2305 if (!
TM.getXCOFFTracebackTable())
2308 emitTracebackTable();
2316 (getNumberOfVRSaved() > 0)) {
2318 OutStreamer->switchSection(getObjFileLowering().getCompactUnwindSection());
2321 OutStreamer->emitLabel(EHInfoLabel);
2324 OutStreamer->emitInt32(0);
2326 const DataLayout &
DL = MMI->getModule()->getDataLayout();
2329 OutStreamer->emitValueToAlignment(
Align(PointerSize));
2331 OutStreamer->emitIntValue(0, PointerSize);
2332 OutStreamer->emitIntValue(0, PointerSize);
2333 OutStreamer->switchSection(MF->
getSection());
2337void PPCAIXAsmPrinter::emitTracebackTable() {
2341 OutStreamer->emitLabel(FuncEnd);
2343 OutStreamer->AddComment(
"Traceback table begin");
2345 OutStreamer->emitIntValueInHexWithPadding(0, 4 );
2350 auto EmitComment = [&]() {
2351 OutStreamer->AddComment(CommentOS.str());
2352 CommentString.
clear();
2357 OutStreamer->emitIntValueInHexWithPadding(
Value,
Size);
2361 CommentOS <<
"Version = " <<
Version;
2362 EmitCommentAndValue(Version, 1);
2372 CommentOS <<
"Language = "
2374 EmitCommentAndValue(LanguageIdentifier, 1);
2377 uint32_t FirstHalfOfMandatoryField = 0;
2388 for (
unsigned Reg = PPC::F0;
Reg <= PPC::F31; ++
Reg) {
2389 if (
MRI.isPhysRegUsed(Reg,
true)) {
2395#define GENBOOLCOMMENT(Prefix, V, Field) \
2396 CommentOS << (Prefix) << ((V) & (TracebackTable::Field##Mask) ? "+" : "-") \
2399#define GENVALUECOMMENT(PrefixAndName, V, Field) \
2400 CommentOS << (PrefixAndName) << " = " \
2401 << static_cast<unsigned>(((V) & (TracebackTable::Field##Mask)) >> \
2402 (TracebackTable::Field##Shift))
2405 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsOutOfLineEpilogOrPrologue);
2408 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, HasTraceBackTableOffset);
2409 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsInternalProcedure);
2412 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, HasControlledStorage);
2416 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, IsFloatingPointPresent);
2419 IsFloatingPointOperationLogOrAbortEnabled);
2422 OutStreamer->emitIntValueInHexWithPadding(
2423 (FirstHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
2431 if (FrameReg == (Subtarget->
isPPC64() ? PPC::X31 : PPC::R31))
2435 if (!MustSaveCRs.
empty())
2441 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, IsInterruptHandler);
2442 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsFunctionNamePresent);
2446 OnConditionDirective);
2450 OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff),
2454 uint32_t SecondHalfOfMandatoryField = 0;
2461 for (
unsigned Reg = PPC::F14;
Reg <= PPC::F31; ++
Reg) {
2462 if (
MRI.isPhysRegModified(Reg)) {
2463 FPRSaved = PPC::F31 -
Reg + 1;
2469 GENBOOLCOMMENT(
"", SecondHalfOfMandatoryField, IsBackChainStored);
2471 GENVALUECOMMENT(
", NumOfFPRsSaved", SecondHalfOfMandatoryField, FPRSaved);
2473 OutStreamer->emitIntValueInHexWithPadding(
2474 (SecondHalfOfMandatoryField & 0xff000000) >> 24, 1);
2480 bool HasVectorInst =
false;
2481 for (
unsigned Reg = PPC::V0;
Reg <= PPC::V31; ++
Reg)
2482 if (
MRI.isPhysRegUsed(Reg,
true)) {
2484 HasVectorInst =
true;
2491 uint16_t NumOfVRSaved = getNumberOfVRSaved();
2492 bool ShouldEmitEHBlock =
2495 if (ShouldEmitEHBlock)
2501 unsigned GPRBegin = Subtarget->
isPPC64() ? PPC::X14 : PPC::R13;
2502 unsigned GPREnd = Subtarget->
isPPC64() ? PPC::X31 : PPC::R31;
2504 for (
unsigned Reg = GPRBegin;
Reg <= GPREnd; ++
Reg) {
2505 if (
MRI.isPhysRegModified(Reg)) {
2506 GPRSaved = GPREnd -
Reg + 1;
2514 GENBOOLCOMMENT(
"", SecondHalfOfMandatoryField, HasExtensionTable);
2516 GENVALUECOMMENT(
", NumOfGPRsSaved", SecondHalfOfMandatoryField, GPRSaved);
2518 OutStreamer->emitIntValueInHexWithPadding(
2519 (SecondHalfOfMandatoryField & 0x00ff0000) >> 16, 1);
2523 SecondHalfOfMandatoryField |=
2527 NumberOfFixedParms);
2529 OutStreamer->emitIntValueInHexWithPadding(
2530 (SecondHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
2538 SecondHalfOfMandatoryField |=
2543 NumberOfFloatingPointParms);
2544 GENBOOLCOMMENT(
", ", SecondHalfOfMandatoryField, HasParmsOnStack);
2546 OutStreamer->emitIntValueInHexWithPadding(SecondHalfOfMandatoryField & 0xff,
2552 if (NumberOfFixedParms || NumberOfFPParms) {
2558 ParmsTypeValue, NumberOfFixedParms, NumberOfFPParms,
2565 CommentOS <<
"Parameter type = " << ParmsType.
get();
2568 OutStreamer->emitIntValueInHexWithPadding(ParmsTypeValue,
2569 sizeof(ParmsTypeValue));
2572 OutStreamer->AddComment(
"Function size");
2574 MCSymbol *FuncSectSym = getObjFileLowering().getFunctionEntryPointSymbol(
2576 OutStreamer->emitAbsoluteSymbolDiff(FuncEnd, FuncSectSym, 4);
2588 int16_t NameLength =
Name.size();
2589 CommentOS <<
"Function name len = "
2590 <<
static_cast<unsigned int>(NameLength);
2591 EmitCommentAndValue(NameLength, 2);
2592 OutStreamer->AddComment(
"Function Name");
2593 OutStreamer->emitBytes(
Name);
2598 OutStreamer->AddComment(
"AllocaUsed");
2599 OutStreamer->emitIntValueInHex(AllocReg,
sizeof(AllocReg));
2632 OutStreamer->emitIntValueInHexWithPadding((VRData & 0xff00) >> 8, 1);
2637 OutStreamer->emitIntValueInHexWithPadding(VRData & 0x00ff, 1);
2645 CommentOS <<
"Vector Parameter type = " << VecParmsType.
get();
2648 OutStreamer->emitIntValueInHexWithPadding(VecParmTypeValue,
2649 sizeof(VecParmTypeValue));
2651 CommentOS <<
"Padding";
2652 EmitCommentAndValue(0, 2);
2655 uint8_t ExtensionTableFlag = 0;
2657 if (ShouldEmitEHBlock)
2658 ExtensionTableFlag |= ExtendedTBTableFlag::TB_EH_INFO;
2661 ExtensionTableFlag |= ExtendedTBTableFlag::TB_SSP_CANARY;
2663 CommentOS <<
"ExtensionTableFlag = "
2665 EmitCommentAndValue(ExtensionTableFlag,
sizeof(ExtensionTableFlag));
2668 if (ExtensionTableFlag & ExtendedTBTableFlag::TB_EH_INFO) {
2669 auto &Ctx = OutStreamer->getContext();
2672 MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(EHInfoSym, TOCType_EHBlock);
2674 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
2675 ->getQualNameSymbol();
2681 OutStreamer->emitValueToAlignment(
Align(4));
2682 OutStreamer->AddComment(
"EHInfo Table");
2683 OutStreamer->emitValue(Exp,
DL.getPointerSize());
2685#undef GENBOOLCOMMENT
2686#undef GENVALUECOMMENT
2695 .
Case(
"llvm.used",
true)
2697 .
Case(
"llvm.compiler.used",
true)
2703 .
Cases(
"llvm.global_ctors",
"llvm.global_dtors",
true)
2708 if (
auto *GA = dyn_cast<GlobalAlias>(
C))
2709 return getAliasOffset(GA->getAliasee());
2710 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
2712 const MCBinaryExpr *CBE = dyn_cast<MCBinaryExpr>(LowC);
2717 auto *
RHS = dyn_cast<MCConstantExpr>(CBE->
getRHS());
2720 return RHS->getValue();
2730 "GlobalVariables with an alignment requirement stricter than TOC entry "
2731 "size not supported by the toc data transformation.");
2734 assert(GVType->
isSized() &&
"A GlobalVariable's size must be known to be "
2735 "supported by the toc data transformation.");
2739 "A GlobalVariable with size larger than a TOC entry is not currently "
2740 "supported by the toc data transformation.");
2743 "currently supported by the toc data transformation.");
2746void PPCAIXAsmPrinter::emitGlobalVariable(
const GlobalVariable *GV) {
2756 TOCDataGlobalVars.push_back(GV);
2760 emitGlobalVariableHelper(GV);
2763void PPCAIXAsmPrinter::emitGlobalVariableHelper(
const GlobalVariable *GV) {
2765 "Unhandled intrinsic global variable.");
2773 emitLinkage(GV, GVSym);
2777 SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV,
TM);
2781 "not supported yet.");
2788 OutStreamer->getCommentOS() <<
'\n';
2793 getObjFileLowering().SectionForGlobal(GV, GVKind,
TM));
2796 OutStreamer->switchSection(Csect);
2809 OutStreamer->emitZeros(
Size);
2812 "BSS local toc-data already handled and TLS variables "
2813 "incompatible with XMC_TD");
2814 OutStreamer->emitXCOFFLocalCommonSymbol(
2818 OutStreamer->emitCommonSymbol(GVSym,
Size, Alignment);
2826 emitLinkage(GV, EmittedInitSym);
2828 emitLinkage(GA, getSymbol(GA));
2830 emitAlignment(getGVAlignment(GV,
DL), GV);
2834 if (!
TM.getDataSections() || GV->hasSection())
2835 OutStreamer->emitLabel(EmittedInitSym);
2838 if (!GOAliasMap[GV].
size()) {
2839 emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
2845 AliasMapTy AliasList;
2847 AliasList[getAliasOffset(GA->getAliasee())].push_back(GA);
2850 emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer(),
2854void PPCAIXAsmPrinter::emitFunctionDescriptor() {
2856 const unsigned PointerSize =
DL.getPointerSizeInBits() == 64 ? 8 : 4;
2860 OutStreamer->switchSection(
2861 cast<MCSymbolXCOFF>(CurrentFnDescSym)->getRepresentedCsect());
2865 OutStreamer->emitLabel(getSymbol(Alias));
2872 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
2873 ->getQualNameSymbol();
2877 OutStreamer->emitIntValue(0, PointerSize);
2879 OutStreamer->switchSection(Current.first, Current.second);
2882void PPCAIXAsmPrinter::emitFunctionEntryLabel() {
2886 PPCAsmPrinter::emitFunctionEntryLabel();
2890 OutStreamer->emitLabel(
2891 getObjFileLowering().getFunctionEntryPointSymbol(Alias,
TM));
2894void PPCAIXAsmPrinter::emitPGORefs(
Module &M) {
2895 if (!OutContext.hasXCOFFSection(
2906 bool HasNonZeroLengthPrfCntsSection =
false;
2909 if (GV.hasSection() && GV.getSection() ==
"__llvm_prf_cnts" &&
2910 DL.getTypeAllocSize(GV.getValueType()) > 0) {
2911 HasNonZeroLengthPrfCntsSection =
true;
2915 if (HasNonZeroLengthPrfCntsSection) {
2916 MCSection *CntsSection = OutContext.getXCOFFSection(
2921 OutStreamer->switchSection(CntsSection);
2922 if (OutContext.hasXCOFFSection(
2925 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_data[RW]");
2926 OutStreamer->emitXCOFFRefDirective(S);
2928 if (OutContext.hasXCOFFSection(
2931 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_names[RO]");
2932 OutStreamer->emitXCOFFRefDirective(S);
2934 if (OutContext.hasXCOFFSection(
2937 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_vnds[RW]");
2938 OutStreamer->emitXCOFFRefDirective(S);
2943void PPCAIXAsmPrinter::emitEndOfAsmFile(
Module &M) {
2946 if (
M.empty() && TOCDataGlobalVars.empty())
2952 OutStreamer->switchSection(getObjFileLowering().getTOCBaseSection());
2957 for (
auto &
I : TOC) {
2964 if (
I.first.second == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM ||
2965 (Subtarget->hasAIXShLibTLSModelOpt() &&
2966 I.first.second == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSLD)) {
2970 Name += cast<MCSymbolXCOFF>(
I.first.first)->getSymbolTableName();
2972 TCEntry = cast<MCSectionXCOFF>(
2973 getObjFileLowering().getSectionForTOCEntry(S,
TM));
2975 TCEntry = cast<MCSectionXCOFF>(
2976 getObjFileLowering().getSectionForTOCEntry(
I.first.first,
TM));
2978 OutStreamer->switchSection(TCEntry);
2980 OutStreamer->emitLabel(
I.second);
2987 for (
const auto *GV : TOCDataGlobalVars) {
2988 if (!GV->hasCommonLinkage())
2989 emitGlobalVariableHelper(GV);
2991 for (
const auto *GV : TOCDataGlobalVars) {
2992 if (GV->hasCommonLinkage())
2993 emitGlobalVariableHelper(GV);
2997bool PPCAIXAsmPrinter::doInitialization(
Module &M) {
2998 const bool Result = PPCAsmPrinter::doInitialization(M);
3000 auto setCsectAlignment = [
this](
const GlobalObject *GO) {
3002 if (GO->isDeclarationForLinker())
3005 SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO,
TM);
3007 getObjFileLowering().SectionForGlobal(GO, GOKind,
TM));
3009 Align GOAlign = getGVAlignment(GO, GO->getParent()->getDataLayout());
3017 auto DL =
M.getDataLayout();
3018 for (
const auto &
G :
M.globals()) {
3019 if (
G.isThreadLocal() && !
G.isDeclaration()) {
3020 TLSVarAddress =
alignTo(TLSVarAddress, getGVAlignment(&
G,
DL));
3021 TLSVarsToAddressMapping[&
G] = TLSVarAddress;
3022 TLSVarAddress +=
DL.getTypeAllocSize(
G.getValueType());
3029 for (
const auto &
G :
M.globals()) {
3036 if (FormatIndicatorAndUniqueModId.empty()) {
3038 if (UniqueModuleId !=
"")
3042 FormatIndicatorAndUniqueModId =
"clang_" + UniqueModuleId.substr(1);
3047 std::chrono::duration_cast<std::chrono::nanoseconds>(
3048 std::chrono::steady_clock::now().time_since_epoch())
3050 FormatIndicatorAndUniqueModId =
3053 llvm::itostr(CurTime);
3057 emitSpecialLLVMGlobal(&
G);
3061 setCsectAlignment(&
G);
3062 std::optional<CodeModel::Model> OptionalCodeModel =
G.getCodeModel();
3063 if (OptionalCodeModel)
3065 *OptionalCodeModel);
3068 for (
const auto &
F : M)
3069 setCsectAlignment(&
F);
3072 for (
const auto &Alias :
M.aliases()) {
3076 "alias without a base object is not yet supported on AIX");
3080 "\n\tAlias attribute for " +
3081 Alias.getGlobalIdentifier() +
3082 " is invalid because " + Aliasee->
getName() +
3088 dyn_cast_or_null<GlobalVariable>(Alias.getAliaseeObject());
3090 std::optional<CodeModel::Model> OptionalCodeModel = GVar->
getCodeModel();
3091 if (OptionalCodeModel)
3093 *OptionalCodeModel);
3096 GOAliasMap[Aliasee].push_back(&Alias);
3103 switch (
MI->getOpcode()) {
3110 if (
MI->getNumOperands() < 5)
3116 MCSymbol *TempSym = OutContext.createNamedTempSymbol();
3117 OutStreamer->emitLabel(TempSym);
3118 OutStreamer->emitXCOFFExceptDirective(CurrentFnSym, TempSym,
3120 Subtarget->
isPPC64() ?
MI->getMF()->getInstructionCount() * 8 :
3121 MI->getMF()->getInstructionCount() * 4,
3122 MMI->hasDebugInfo());
3125 case PPC::GETtlsMOD32AIX:
3126 case PPC::GETtlsMOD64AIX:
3127 case PPC::GETtlsTpointer32AIX:
3128 case PPC::GETtlsADDR64AIX:
3129 case PPC::GETtlsADDR32AIX: {
3134 ExtSymSDNodeSymbols.insert(TlsGetAddr);
3144 cast<MCSymbolXCOFF>(OutContext.getOrCreateSymbol(MO.
getSymbolName()));
3145 ExtSymSDNodeSymbols.insert(S);
3151 case PPC::BL8_NOP_TLS:
3158 case PPC::TAILBCTR8:
3159 if (
MI->getOperand(0).isSymbol())
3172 MCInstBuilder(PPC::ORI).addReg(PPC::R0).addReg(PPC::R0).addImm(0));
3175 return PPCAsmPrinter::emitInstruction(
MI);
3178bool PPCAIXAsmPrinter::doFinalization(
Module &M) {
3180 if (!MAI->usesDwarfFileAndLocDirectives() && MMI->hasDebugInfo())
3181 OutStreamer->doFinalizationAtSectionEnd(
3182 OutStreamer->getContext().getObjectFileInfo()->getTextSection());
3186 return PPCAsmPrinter::doFinalization(M);
3190 if (P < 0 || P > 65535)
3197 return 20 + (
P - 20) * 16;
3200 return 1004 + (
P - 81);
3203 return 2047 + (
P - 1124) * 33878;
3205 return 2147482625u + (
P - 64512);
3224 std::string PrioritySuffix;
3228 return PrioritySuffix;
3231void PPCAIXAsmPrinter::emitXXStructorList(
const DataLayout &
DL,
3232 const Constant *List,
bool IsCtor) {
3234 preprocessXXStructorList(
DL, List, Structors);
3235 if (Structors.
empty())
3239 for (Structor &S : Structors) {
3240 if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(S.Func))
3241 S.Func =
CE->getOperand(0);
3249 cast<Function>(S.Func));
3253void PPCAIXAsmPrinter::emitTTypeReference(
const GlobalValue *GV,
3254 unsigned Encoding) {
3256 TOCEntryType GlobalType = TOCType_GlobalInternal;
3261 GlobalType = TOCType_GlobalExternal;
3263 MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(TypeInfoSym, GlobalType);
3265 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
3266 ->getQualNameSymbol();
3267 auto &Ctx = OutStreamer->getContext();
3271 OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
3273 OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
3280 std::unique_ptr<MCStreamer> &&Streamer) {
3282 return new PPCAIXAsmPrinter(tm, std::move(Streamer));
3284 return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
3287void PPCAIXAsmPrinter::emitModuleCommandLines(
Module &M) {
3288 const NamedMDNode *NMD =
M.getNamedMetadata(
"llvm.commandline");
3296 assert(
N->getNumOperands() == 1 &&
3297 "llvm.commandline metadata entry can have only one operand");
3298 const MDString *MDS = cast<MDString>(
N->getOperand(0));
3301 RSOS <<
"@(#)opt " << MDS->
getString() <<
"\n";
3304 OutStreamer->emitXCOFFCInfoSym(
".GCC.command.line", RSOS.str());
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_EXTERNAL_VISIBILITY
static std::string getRegisterName(const TargetRegisterInfo *TRI, Register Reg)
This file implements a map that provides insertion order iteration.
Module.h This file contains the declarations for the Module class.
static void collectTOCStats(PPCAsmPrinter::TOCEntryType Type)
static bool isSpecialLLVMGlobalArrayForStaticInit(const GlobalVariable *GV)
static bool isSpecialLLVMGlobalArrayToSkip(const GlobalVariable *GV)
LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCAsmPrinter()
#define GENBOOLCOMMENT(Prefix, V, Field)
static MCSymbol * getMCSymbolForTOCPseudoMO(const MachineOperand &MO, AsmPrinter &AP)
Map a machine operand for a TOC pseudo-machine instruction to its corresponding MCSymbol.
static void setOptionalCodeModel(MCSymbolXCOFF *XSym, CodeModel::Model CM)
static AsmPrinter * createPPCAsmPrinterPass(TargetMachine &tm, std::unique_ptr< MCStreamer > &&Streamer)
static PPCAsmPrinter::TOCEntryType getTOCEntryTypeForMO(const MachineOperand &MO)
static CodeModel::Model getCodeModel(const PPCSubtarget &S, const TargetMachine &TM, const MachineOperand &MO)
static std::string convertToSinitPriority(int Priority)
static MCSymbol * createMCSymbolForTlsGetAddr(MCContext &Ctx, unsigned MIOpc)
This helper function creates the TlsGetAddr/TlsGetMod MCSymbol for AIX.
#define GENVALUECOMMENT(PrefixAndName, V, Field)
static unsigned mapToSinitPriority(int P)
static void tocDataChecks(unsigned PointerSize, const GlobalVariable *GV)
static cl::opt< bool > EnableSSPCanaryBitInTB("aix-ssp-tb-bit", cl::init(false), cl::desc("Enable Passing SSP Canary info in Trackback on AIX"), cl::Hidden)
const char LLVMTargetMachineRef TM
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
Provides a library for accessing information about this process and other processes on the operating ...
static SDValue lowerConstant(SDValue Op, SelectionDAG &DAG, const RISCVSubtarget &Subtarget)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
This file implements a set that has insertion order iteration characteristics.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
This class is intended to be used as a driving class for all asm writers.
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
MCSymbol * getSymbol(const GlobalValue *GV) const
void emitXRayTable()
Emit a table with all XRay instrumentation points.
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS)
Print the MachineOperand as a symbol.
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
virtual void emitStartOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the start of their fi...
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
virtual bool PrintAsmMemoryOperand(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 as...
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
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.
A constant value that is initialized with an expression using other constant values.
This is an important base class in LLVM.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
unsigned getPointerSize(unsigned AS=0) const
Layout pointer size in bytes, rounded up to a whole number of bytes.
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
reference get()
Returns a reference to the stored T value.
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
bool hasSection() const
Check if this global has a custom object file section.
VisibilityTypes getVisibility() const
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
LinkageTypes getLinkage() const
bool hasDefaultVisibility() const
bool hasPrivateLinkage() const
ThreadLocalMode getThreadLocalMode() const
bool hasDLLExportStorageClass() const
bool isDeclarationForLinker() const
Module * getParent()
Get the module that this global value is contained inside of...
const GlobalObject * getAliaseeObject() const
@ DefaultVisibility
The GV is visible.
@ HiddenVisibility
The GV is hidden.
@ ProtectedVisibility
The GV is protected.
bool hasCommonLinkage() const
bool hasAppendingLinkage() const
LinkageTypes
An enumeration for the kinds of linkage for global values.
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ CommonLinkage
Tentative definitions.
@ InternalLinkage
Rename collisions when linking (static functions).
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
@ WeakODRLinkage
Same, but only replaced by something equivalent.
@ ExternalLinkage
Externally visible function.
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
@ AppendingLinkage
Special purpose, only applies to global arrays.
@ AvailableExternallyLinkage
Available for inspection, not emission.
@ ExternalWeakLinkage
ExternalWeak linkage description.
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Type * getValueType() const
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists.
bool hasInitializer() const
Definitions have initializers, declarations don't.
std::optional< CodeModel::Model > getCodeModel() const
Get the custom code model of this global if it has one.
Binary assembler expressions.
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Opcode getOpcode() const
Get the kind of this binary expression.
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Context object for machine code objects.
MCSectionXCOFF * getXCOFFSection(StringRef Section, SectionKind K, std::optional< XCOFF::CsectProperties > CsectProp=std::nullopt, bool MultiSymbolsAllowed=false, const char *BeginSymName=nullptr, std::optional< XCOFF::DwarfSectionSubtypeFlags > DwarfSubtypeFlags=std::nullopt)
Base class for the full range of assembler expressions which are needed for parsing.
MCInstBuilder & addReg(unsigned Reg)
Add a new register operand.
MCInstBuilder & addImm(int64_t Val)
Add a new integer immediate operand.
MCInstBuilder & addExpr(const MCExpr *Val)
Add a new MCExpr operand.
Instances of this class represent a single low-level machine instruction.
void addOperand(const MCOperand Op)
void setOpcode(unsigned Op)
const MCOperand & getOperand(unsigned i) const
Instances of this class represent operands of the MCInst class.
static MCOperand createExpr(const MCExpr *Val)
unsigned getReg() const
Returns the register number.
This represents a section on linux, lots of unix variants and some bare metal systems.
XCOFF::StorageMappingClass getMappingClass() const
MCSymbolXCOFF * getQualNameSymbol() const
Instances of this class represent a uniqued identifier for a section in the current translation unit.
void setAlignment(Align Value)
void ensureMinAlignment(Align MinAlignment)
Makes sure that Alignment is at least MinAlignment.
Represent a reference to a symbol from inside an expression.
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
StringRef getSymbolTableName() const
void setPerSymbolCodeModel(MCSymbolXCOFF::CodeModel Model)
void setStorageClass(XCOFF::StorageClass SC)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
StringRef getString() const
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
MCSection * getSection() const
Returns the Section this function belongs to.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Representation of each machine instruction.
MachineOperand class - Representation of each machine instruction operand.
const GlobalValue * getGlobal() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
MachineBasicBlock * getMBB() const
bool isCPI() const
isCPI - Tests if this is a MO_ConstantPoolIndex 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.
bool isJTI() const
isJTI - Tests if this is a MO_JumpTableIndex operand.
const BlockAddress * getBlockAddress() const
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.
const char * getSymbolName() const
bool isBlockAddress() const
isBlockAddress - Tests if this is a MO_BlockAddress 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_MachineBasicBlock
MachineBasicBlock reference.
@ MO_Register
Register operand.
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
int64_t getOffset() const
Return the offset from the symbol in this operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
This class implements a map that also provides access to all stored values in a deterministic order.
iterator find(const KeyT &Key)
A Module instance is used to store all the information related to an LLVM module.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
MDNode * getOperand(unsigned i) const
unsigned getNumOperands() const
uint64_t getTOCSaveOffset() const
getTOCSaveOffset - Return the previous frame offset to save the TOC register – 64-bit SVR4 ABI only.
PPCFunctionInfo - This class is derived from MachineFunction private PowerPC target-specific informat...
uint32_t getParmsType() const
MCSymbol * getPICOffsetSymbol(MachineFunction &MF) const
const SmallVectorImpl< Register > & getMustSaveCRs() const
unsigned getFloatingPointParmsNum() const
bool isAIXFuncUseTLSIEForLD() const
MCSymbol * getGlobalEPSymbol(MachineFunction &MF) const
MCSymbol * getLocalEPSymbol(MachineFunction &MF) const
unsigned getVectorParmsNum() const
int getVarArgsFrameIndex() const
bool usesTOCBasePtr() const
bool hasVectorParms() const
uint32_t getVecExtParmsType() const
MCSymbol * getTOCOffsetSymbol(MachineFunction &MF) const
unsigned getFixedParmsNum() const
static const char * getRegisterName(MCRegister Reg)
static bool hasTLSFlag(unsigned TF)
static const PPCMCExpr * createLo(const MCExpr *Expr, MCContext &Ctx)
static const PPCMCExpr * createHa(const MCExpr *Expr, MCContext &Ctx)
bool is32BitELFABI() const
const PPCFrameLowering * getFrameLowering() const override
bool isPPC64() const
isPPC64 - Return true if we are generating code for 64-bit pointer mode.
bool isUsingPCRelativeCalls() const
CodeModel::Model getCodeModel(const TargetMachine &TM, const GlobalValue *GV) const
Calculates the effective code model for argument GV.
const PPCRegisterInfo * getRegisterInfo() const override
bool isGVIndirectSymbol(const GlobalValue *GV) const
True if the GV will be accessed via an indirect symbol.
Common code between 32-bit and 64-bit PowerPC targets.
bool hasGlibcHWCAPAccess() const
virtual void emitAbiVersion(int AbiVersion)
virtual void emitTCEntry(const MCSymbol &S, MCSymbolRefExpr::VariantKind Kind)
virtual void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset)
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
MI-level patchpoint operands.
Wrapper class representing virtual and physical registers.
SectionKind - This is a simple POD value that classifies the properties of a section.
bool isThreadBSSLocal() const
static SectionKind getText()
static SectionKind getData()
bool isThreadLocal() const
bool isGlobalWriteableData() const
A SetVector that performs no allocations if smaller than a certain size.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
void recordPatchPoint(const MCSymbol &L, const MachineInstr &MI)
Generate a stackmap record for a patchpoint instruction.
void recordStackMap(const MCSymbol &L, const MachineInstr &MI)
Generate a stackmap record for a stackmap instruction.
StringRef - Represent a constant reference to a string, i.e.
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
StringSwitch & Cases(StringLiteral S0, StringLiteral S1, T Value)
static bool ShouldSetSSPCanaryBitInTB(const MachineFunction *MF)
static MCSymbol * getEHInfoTableSymbol(const MachineFunction *MF)
static XCOFF::StorageClass getStorageClassForGlobal(const GlobalValue *GV)
static bool ShouldEmitEHBlock(const MachineFunction *MF)
Primary interface to the complete machine description for the target machine.
const Triple & getTargetTriple() const
bool isOSAIX() const
Tests whether the OS is AIX.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
LLVM Value Representation.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Align getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
StringRef getName() const
Return a constant reference to the value's name.
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
A raw_ostream that writes to an SmallVector or SmallString.
static Pid getProcessId()
Get the process's identifier.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
@ C
The default llvm calling convention, compatible with C.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
@ MO_TLSLDM_FLAG
MO_TLSLDM_FLAG - on AIX the ML relocation type is only valid for a reference to a TOC symbol from the...
@ MO_TPREL_PCREL_FLAG
MO_TPREL_PCREL_FLAG = MO_PCREL_FLAG | MO_TPREL_FLAG.
@ MO_GOT_TPREL_PCREL_FLAG
MO_GOT_TPREL_PCREL_FLAG - A combintaion of flags, if these bits are set they should produce the reloc...
@ MO_TLSGDM_FLAG
MO_TLSGDM_FLAG - If this bit is set the symbol reference is relative to the region handle of TLS Gene...
@ MO_TLSLD_FLAG
MO_TLSLD_FLAG - If this bit is set the symbol reference is relative to TLS Local Dynamic model.
@ MO_TPREL_FLAG
MO_TPREL_FLAG - If this bit is set, the symbol reference is relative to the thread pointer and the sy...
@ MO_GOT_TLSLD_PCREL_FLAG
MO_GOT_TLSLD_PCREL_FLAG - A combintaion of flags, if these bits are set they should produce the reloc...
@ MO_TLSGD_FLAG
MO_TLSGD_FLAG - If this bit is set the symbol reference is relative to TLS General Dynamic model for ...
@ MO_GOT_TLSGD_PCREL_FLAG
MO_GOT_TLSGD_PCREL_FLAG - A combintaion of flags, if these bits are set they should produce the reloc...
Predicate
Predicate - These are "(BI << 5) | BO" for various predicates.
const char * stripRegisterPrefix(const char *RegName)
stripRegisterPrefix - This method strips the character prefix from a register name so that only the n...
Predicate InvertPredicate(Predicate Opcode)
Invert the specified predicate. != -> ==, < -> >=.
static bool isVRRegister(unsigned Reg)
static bool isVFRegister(unsigned Reg)
@ CE
Windows NT (Windows on ARM)
Reg
All possible values of the reg field in the ModR/M byte.
SmallString< 32 > getExtendedTBTableFlagString(uint8_t Flag)
Expected< SmallString< 32 > > parseParmsTypeWithVecInfo(uint32_t Value, unsigned FixedParmsNum, unsigned FloatingParmsNum, unsigned VectorParmsNum)
Expected< SmallString< 32 > > parseParmsType(uint32_t Value, unsigned FixedParmsNum, unsigned FloatingParmsNum)
Expected< SmallString< 32 > > parseVectorParmsType(uint32_t Value, unsigned ParmsNum)
@ XMC_RO
Read Only Constant.
@ XMC_TD
Scalar data item in the TOC.
StringRef getNameForTracebackTableLanguageId(TracebackTable::LanguageID LangId)
constexpr uint8_t AllocRegNo
@ XTY_SD
Csect definition for initialized storage.
@ XTY_ER
External reference.
initializer< Ty > init(const Ty &Val)
static unsigned combineHashValue(unsigned a, unsigned b)
Simplistic combination of 32-bit hash values into 32-bit hash values.
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
constexpr uint64_t PointerSize
aarch64 pointer size.
Linkage
Describes symbol linkage. This can be used to resolve definition clashes.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Target & getThePPC64LETarget()
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool LowerPPCMachineOperandToMCOperand(const MachineOperand &MO, MCOperand &OutMO, AsmPrinter &AP)
Target & getThePPC32Target()
std::string getUniqueModuleId(Module *M)
Produce a unique identifier for this module by taking the MD5 sum of the names of the module's strong...
void LowerPPCMachineInstrToMCInst(const MachineInstr *MI, MCInst &OutMI, AsmPrinter &AP)
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width, bool Upper=false)
format_hex_no_prefix - Output N as a fixed width hexadecimal.
Target & getThePPC64Target()
uint64_t get_threadid()
Return the current thread id, as used in various OS system calls.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
std::pair< MCSection *, const MCExpr * > MCSectionSubPair
Target & getThePPC32LETarget()
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
@ MCSA_Global
.type _foo, @gnu_unique_object
@ MCSA_Extern
.extern (XCOFF)
@ MCSA_LGlobal
.lglobl (XCOFF)
@ MCSA_Invalid
Not a valid directive.
Implement std::hash so that hash_code can be used in STL containers.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
static unsigned getHashValue(const TOCKey &PairVal)
static bool isEqual(const TOCKey &A, const TOCKey &B)
std::pair< const MCSymbol *, MCSymbolRefExpr::VariantKind > TOCKey
static TOCKey getTombstoneKey()
static TOCKey getEmptyKey()
An information struct used to provide DenseMap with the various necessary components for a given valu...
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn)
RegisterAsmPrinter - Register an AsmPrinter implementation for the given target.
static constexpr uint32_t FPRSavedMask
static constexpr uint16_t NumberOfVRSavedMask
static constexpr uint8_t NumberOfFloatingPointParmsShift
static constexpr uint32_t NumberOfFixedParmsMask
static constexpr uint16_t HasVMXInstructionMask
static constexpr uint32_t IsLRSavedMask
static constexpr uint16_t HasVarArgsMask
static constexpr uint32_t IsAllocaUsedMask
static constexpr uint16_t IsVRSavedOnStackMask
static constexpr uint16_t NumberOfVectorParmsMask
static constexpr uint32_t IsFloatingPointPresentMask
static constexpr uint32_t FPRSavedShift
static constexpr uint32_t NumberOfFloatingPointParmsMask
static constexpr uint32_t HasControlledStorageMask
static constexpr uint32_t HasExtensionTableMask
static constexpr uint32_t HasTraceBackTableOffsetMask
static constexpr uint32_t IsCRSavedMask
static constexpr uint8_t NumberOfFixedParmsShift
static constexpr uint32_t GPRSavedMask
static constexpr uint8_t NumberOfVectorParmsShift
static constexpr uint32_t HasParmsOnStackMask
static constexpr uint32_t IsFunctionNamePresentMask
static constexpr uint32_t IsBackChainStoredMask
static constexpr uint32_t IsInterruptHandlerMask
static constexpr uint32_t HasVectorInfoMask
static constexpr uint8_t NumberOfVRSavedShift
static constexpr uint32_t GPRSavedShift