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 HasAIXSmallLocalExecTLS = Subtarget->hasAIXSmallLocalExecTLS();
807 const Module *
M = MF->getFunction().getParent();
812 if (!
MI->isInlineAsm()) {
816 if (Subtarget->hasSPE()) {
817 if (PPC::F4RCRegClass.
contains(Reg) ||
826 if (PPC::SPERCRegClass.
contains(Reg))
834 auto getTOCRelocAdjustedExprForXCOFF = [
this](
const MCExpr *Expr,
843 OriginalOffset - llvm::SignExtend32<16>(OriginalOffset);
848 auto getTOCEntryLoadingExprForXCOFF =
849 [IsPPC64, getTOCRelocAdjustedExprForXCOFF,
852 MCSymbolRefExpr::VariantKind::VK_None) ->
const MCExpr * {
853 const unsigned EntryByteSize = IsPPC64 ? 8 : 4;
854 const auto TOCEntryIter =
TOC.find({MOSymbol, VK});
856 "Could not find the TOC entry for this symbol.");
857 const ptrdiff_t EntryDistanceFromTOCBase =
858 (TOCEntryIter -
TOC.begin()) * EntryByteSize;
859 constexpr int16_t PositiveTOCRange = INT16_MAX;
861 if (EntryDistanceFromTOCBase > PositiveTOCRange)
862 return getTOCRelocAdjustedExprForXCOFF(Expr, EntryDistanceFromTOCBase);
874 assert(MO.
isGlobal() &&
"Only expecting a global MachineOperand here!\n");
877 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSLE;
879 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSIE;
886 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM;
888 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGD;
893 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSLD;
895 return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSML;
896 return MCSymbolRefExpr::VariantKind::VK_None;
900 switch (
MI->getOpcode()) {
902 case TargetOpcode::DBG_VALUE:
904 case TargetOpcode::STACKMAP:
905 return LowerSTACKMAP(SM, *
MI);
906 case TargetOpcode::PATCHPOINT:
907 return LowerPATCHPOINT(SM, *
MI);
909 case PPC::MoveGOTtoLR: {
917 OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
926 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BL).addExpr(OffsExpr));
929 case PPC::MovePCtoLR:
930 case PPC::MovePCtoLR8: {
935 MCSymbol *PICBase = MF->getPICBaseSymbol();
938 EmitToStreamer(*OutStreamer,
945 OutStreamer->emitLabel(PICBase);
948 case PPC::UpdateGBR: {
957 if (Subtarget->isSecurePlt() && isPositionIndependent() ) {
959 MCSymbol *BaseSymbol = OutContext.getOrCreateSymbol(
971 MCInstBuilder(PPC::ADDIS).addReg(PICR).addReg(PICR).addExpr(DeltaHi));
976 MCInstBuilder(PPC::ADDI).addReg(PICR).addReg(PICR).addExpr(DeltaLo));
996 EmitToStreamer(*OutStreamer, TmpInst);
1002 EmitToStreamer(*OutStreamer, TmpInst);
1015 "Invalid operand for LWZtoc.");
1027 EmitToStreamer(*OutStreamer, TmpInst);
1047 "This pseudo should only be selected for 32-bit small code model.");
1048 Exp = getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK);
1053 OutStreamer->getCommentOS() << MO <<
'\n';
1054 EmitToStreamer(*OutStreamer, TmpInst);
1061 OutContext.getOrCreateSymbol(
Twine(
".LTOC")), OutContext);
1064 EmitToStreamer(*OutStreamer, TmpInst);
1068 case PPC::ADDItoc8: {
1070 "PseudoOp only valid for small code model AIX");
1076 TmpInst.
setOpcode((!IsPPC64) ? (PPC::LA) : (PPC::LA8));
1089 EmitToStreamer(*OutStreamer, TmpInst);
1104 "Invalid operand!");
1121 IsAIX ? getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK) : Exp);
1124 if (isVerbose() && IsAIX)
1125 OutStreamer->getCommentOS() << MO <<
'\n';
1126 EmitToStreamer(*OutStreamer, TmpInst);
1129 case PPC::ADDIStocHA: {
1133 "Invalid operand for ADDIStocHA.");
1134 assert((IsAIX && !IsPPC64 &&
1136 "This pseudo should only be selected for 32-bit large code model on"
1160 EmitToStreamer(*OutStreamer, TmpInst);
1163 case PPC::LWZtocL: {
1167 "Invalid operand for LWZtocL.");
1168 assert(IsAIX && !IsPPC64 &&
1170 "This pseudo should only be selected for 32-bit large code model on"
1194 EmitToStreamer(*OutStreamer, TmpInst);
1197 case PPC::ADDIStocHA8: {
1209 "Invalid operand for ADDIStocHA8!");
1215 const bool GlobalToc =
1237 EmitToStreamer(*OutStreamer, TmpInst);
1253 "Invalid operand for LDtocL!");
1257 "LDtocL used on symbol that could be accessed directly is "
1258 "invalid. Must match ADDIStocHA8."));
1272 EmitToStreamer(*OutStreamer, TmpInst);
1275 case PPC::ADDItocL8: {
1289 "Interposable definitions must use indirect access."));
1295 EmitToStreamer(*OutStreamer, TmpInst);
1298 case PPC::ADDISgotTprelHA: {
1301 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1304 MCSymbol *MOSymbol = getSymbol(GValue);
1305 const MCExpr *SymGotTprel =
1309 .addReg(
MI->getOperand(0).getReg())
1310 .
addReg(
MI->getOperand(1).getReg())
1314 case PPC::LDgotTprelL:
1315 case PPC::LDgotTprelL32: {
1320 TmpInst.
setOpcode(IsPPC64 ? PPC::LD : PPC::LWZ);
1323 MCSymbol *MOSymbol = getSymbol(GValue);
1329 EmitToStreamer(*OutStreamer, TmpInst);
1333 case PPC::PPC32PICGOT: {
1334 MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
1335 MCSymbol *GOTRef = OutContext.createTempSymbol();
1336 MCSymbol *NextInstr = OutContext.createTempSymbol();
1346 OutStreamer->emitLabel(GOTRef);
1347 OutStreamer->emitValue(OffsExpr, 4);
1348 OutStreamer->emitLabel(NextInstr);
1350 .addReg(
MI->getOperand(0).getReg()));
1352 .addReg(
MI->getOperand(1).getReg())
1354 .
addReg(
MI->getOperand(0).getReg()));
1356 .addReg(
MI->getOperand(0).getReg())
1357 .
addReg(
MI->getOperand(1).getReg())
1358 .
addReg(
MI->getOperand(0).getReg()));
1361 case PPC::PPC32GOT: {
1363 OutContext.getOrCreateSymbol(
StringRef(
"_GLOBAL_OFFSET_TABLE_"));
1369 .addReg(
MI->getOperand(0).getReg())
1372 .addReg(
MI->getOperand(0).getReg())
1373 .
addReg(
MI->getOperand(0).getReg())
1377 case PPC::ADDIStlsgdHA: {
1380 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1383 MCSymbol *MOSymbol = getSymbol(GValue);
1384 const MCExpr *SymGotTlsGD =
1388 .addReg(
MI->getOperand(0).getReg())
1389 .
addReg(
MI->getOperand(1).getReg())
1393 case PPC::ADDItlsgdL:
1396 case PPC::ADDItlsgdL32: {
1401 MCSymbol *MOSymbol = getSymbol(GValue);
1406 EmitToStreamer(*OutStreamer,
1408 .addReg(
MI->getOperand(0).getReg())
1409 .
addReg(
MI->getOperand(1).getReg())
1413 case PPC::GETtlsMOD32AIX:
1414 case PPC::GETtlsMOD64AIX:
1418 case PPC::GETtlsADDR:
1421 case PPC::GETtlsADDRPCREL:
1422 case PPC::GETtlsADDR32AIX:
1423 case PPC::GETtlsADDR64AIX:
1427 case PPC::GETtlsADDR32: {
1433 case PPC::GETtlsTpointer32AIX: {
1436 EmitAIXTlsCallHelper(
MI);
1439 case PPC::ADDIStlsldHA: {
1442 assert(IsPPC64 &&
"Not supported for 32-bit PowerPC");
1445 MCSymbol *MOSymbol = getSymbol(GValue);
1446 const MCExpr *SymGotTlsLD =
1450 .addReg(
MI->getOperand(0).getReg())
1451 .
addReg(
MI->getOperand(1).getReg())
1455 case PPC::ADDItlsldL:
1458 case PPC::ADDItlsldL32: {
1463 MCSymbol *MOSymbol = getSymbol(GValue);
1468 EmitToStreamer(*OutStreamer,
1470 .addReg(
MI->getOperand(0).getReg())
1471 .
addReg(
MI->getOperand(1).getReg())
1475 case PPC::GETtlsldADDR:
1478 case PPC::GETtlsldADDRPCREL:
1479 case PPC::GETtlsldADDR32: {
1485 case PPC::ADDISdtprelHA:
1488 case PPC::ADDISdtprelHA32: {
1493 MCSymbol *MOSymbol = getSymbol(GValue);
1494 const MCExpr *SymDtprel =
1500 .addReg(
MI->getOperand(0).getReg())
1501 .
addReg(
MI->getOperand(1).getReg())
1505 case PPC::PADDIdtprel: {
1510 MCSymbol *MOSymbol = getSymbol(GValue);
1514 .addReg(
MI->getOperand(0).getReg())
1515 .
addReg(
MI->getOperand(1).getReg())
1520 case PPC::ADDIdtprelL:
1523 case PPC::ADDIdtprelL32: {
1528 MCSymbol *MOSymbol = getSymbol(GValue);
1529 const MCExpr *SymDtprel =
1532 EmitToStreamer(*OutStreamer,
1534 .addReg(
MI->getOperand(0).getReg())
1535 .
addReg(
MI->getOperand(1).getReg())
1541 if (!Subtarget->hasMFOCRF()) {
1544 unsigned NewOpcode =
1545 MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
1549 .addReg(
MI->getOperand(0).getReg()));
1555 if (!Subtarget->hasMFOCRF()) {
1558 unsigned NewOpcode =
1559 MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
1560 unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
1561 ->getEncodingValue(
MI->getOperand(0).getReg());
1566 .addReg(
MI->getOperand(1).getReg()));
1576 unsigned OpNum = (
MI->getOpcode() == PPC::STD) ? 2 : 1;
1582 TempMO.getOperandNo() == 1)
1619 if (!HasAIXSmallLocalExecTLS)
1621 bool IsMIADDI8 =
MI->getOpcode() == PPC::ADDI8;
1622 unsigned OpNum = IsMIADDI8 ? 2 : 1;
1638 EmitToStreamer(*OutStreamer, TmpInst);
1644 case PPC::PseudoEIEIO: {
1647 MCInstBuilder(PPC::ORI).addReg(PPC::X2).addReg(PPC::X2).addImm(0));
1650 MCInstBuilder(PPC::ORI).addReg(PPC::X2).addReg(PPC::X2).addImm(0));
1651 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::EnforceIEIO));
1657 EmitToStreamer(*OutStreamer, TmpInst);
1673 assert(MO.
isGlobal() &&
"Only expecting a global MachineOperand here!");
1676 "Only local-exec accesses are handled!");
1682 const auto TLSVarsMapEntryIter = TLSVarsToAddressMapping.
find(GValue);
1683 if (TLSVarsMapEntryIter == TLSVarsToAddressMapping.
end())
1684 assert(IsGlobalADeclaration &&
1685 "Only expecting to find extern TLS variables not present in the TLS "
1686 "variable-to-address map!");
1688 unsigned TLSVarAddress =
1689 IsGlobalADeclaration ? 0 : TLSVarsMapEntryIter->second;
1700 if (FinalAddress >= 32768) {
1707 ptrdiff_t Delta = ((FinalAddress + 32768) & ~0xFFFF);
1710 assert(((InstDisp < 32768) &&
1711 (InstDisp >= -32768)) &&
1712 "Expecting the instruction displacement for local-exec TLS "
1713 "variables to be between [-32768, 32768)!");
1721void PPCLinuxAsmPrinter::emitGNUAttributes(
Module &M) {
1723 Metadata *MD =
M.getModuleFlag(
"float-abi");
1724 MDString *FloatABI = dyn_cast_or_null<MDString>(MD);
1729 if (flt ==
"doubledouble")
1730 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1731 Val_GNU_Power_ABI_HardFloat_DP |
1732 Val_GNU_Power_ABI_LDBL_IBM128);
1733 else if (flt ==
"ieeequad")
1734 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1735 Val_GNU_Power_ABI_HardFloat_DP |
1736 Val_GNU_Power_ABI_LDBL_IEEE128);
1737 else if (flt ==
"ieeedouble")
1738 OutStreamer->emitGNUAttribute(Tag_GNU_Power_ABI_FP,
1739 Val_GNU_Power_ABI_HardFloat_DP |
1740 Val_GNU_Power_ABI_LDBL_64);
1743void PPCLinuxAsmPrinter::emitInstruction(
const MachineInstr *
MI) {
1745 return PPCAsmPrinter::emitInstruction(
MI);
1747 switch (
MI->getOpcode()) {
1749 return PPCAsmPrinter::emitInstruction(
MI);
1750 case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
1762 MCSymbol *BeginOfSled = OutContext.createTempSymbol();
1763 MCSymbol *EndOfSled = OutContext.createTempSymbol();
1764 OutStreamer->emitLabel(BeginOfSled);
1765 EmitToStreamer(*OutStreamer,
1771 MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
1772 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
1773 EmitToStreamer(*OutStreamer,
1776 OutContext.getOrCreateSymbol(
"__xray_FunctionEntry"),
1778 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
1779 OutStreamer->emitLabel(EndOfSled);
1780 recordSled(BeginOfSled, *
MI, SledKind::FUNCTION_ENTER, 2);
1783 case TargetOpcode::PATCHABLE_RET: {
1784 unsigned RetOpcode =
MI->getOperand(0).getImm();
1794 if (RetOpcode == PPC::BCCLR) {
1795 IsConditional =
true;
1796 }
else if (RetOpcode == PPC::TCRETURNdi8 || RetOpcode == PPC::TCRETURNri8 ||
1797 RetOpcode == PPC::TCRETURNai8) {
1799 }
else if (RetOpcode == PPC::BLR8 || RetOpcode == PPC::TAILB8) {
1800 IsConditional =
false;
1802 EmitToStreamer(*OutStreamer, RetInst);
1807 if (IsConditional) {
1826 FallthroughLabel = OutContext.createTempSymbol();
1832 .
addReg(
MI->getOperand(2).getReg())
1849 OutStreamer->emitCodeAlignment(
Align(8), &getSubtargetInfo());
1850 MCSymbol *BeginOfSled = OutContext.createTempSymbol();
1851 OutStreamer->emitLabel(BeginOfSled);
1852 EmitToStreamer(*OutStreamer, RetInst);
1856 MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
1857 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
1858 EmitToStreamer(*OutStreamer,
1861 OutContext.getOrCreateSymbol(
"__xray_FunctionExit"),
1863 EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
1864 EmitToStreamer(*OutStreamer, RetInst);
1866 OutStreamer->emitLabel(FallthroughLabel);
1867 recordSled(BeginOfSled, *
MI, SledKind::FUNCTION_EXIT, 2);
1870 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
1872 case TargetOpcode::PATCHABLE_TAIL_CALL:
1876 "around this assert.");
1880void PPCLinuxAsmPrinter::emitStartOfAsmFile(
Module &M) {
1888 !isPositionIndependent())
1894 OutStreamer->switchSection(OutContext.getELFSection(
1897 MCSymbol *TOCSym = OutContext.getOrCreateSymbol(
Twine(
".LTOC"));
1898 MCSymbol *CurrentPos = OutContext.createTempSymbol();
1900 OutStreamer->emitLabel(CurrentPos);
1909 OutStreamer->emitAssignment(TOCSym, tocExpr);
1911 OutStreamer->switchSection(getObjFileLowering().getTextSection());
1914void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
1917 (!isPositionIndependent() ||
1923 if (PPCFI->
usesPICBase() && !Subtarget->isSecurePlt()) {
1925 MCSymbol *PICBase = MF->getPICBaseSymbol();
1926 OutStreamer->emitLabel(RelocSymbol);
1934 OutStreamer->emitValue(OffsExpr, 4);
1935 OutStreamer->emitLabel(CurrentFnSym);
1948 && !MF->getRegInfo().use_empty(PPC::X2)) {
1953 const MCExpr *TOCDeltaExpr =
1960 OutStreamer->emitValue(TOCDeltaExpr, 8);
1969 OutStreamer->switchSection(Section);
1970 OutStreamer->emitLabel(CurrentFnSym);
1971 OutStreamer->emitValueToAlignment(
Align(8));
1972 MCSymbol *Symbol1 = CurrentFnSymForSize;
1979 OutStreamer->emitValue(
1983 OutStreamer->emitIntValue(0, 8 );
1984 OutStreamer->switchSection(Current.first, Current.second);
1987void PPCLinuxAsmPrinter::emitEndOfAsmFile(
Module &M) {
1990 bool isPPC64 =
DL.getPointerSizeInBits() == 64;
2000 OutStreamer->emitSymbolValue(
2001 GetExternalSymbolSymbol(
"__parse_hwcap_and_convert_at_platform"),
2002 MAI->getCodePointerSize());
2003 emitGNUAttributes(M);
2006 const char *
Name = isPPC64 ?
".toc" :
".got2";
2009 OutStreamer->switchSection(Section);
2011 OutStreamer->emitValueToAlignment(
Align(4));
2013 for (
const auto &TOCMapPair : TOC) {
2014 const MCSymbol *
const TOCEntryTarget = TOCMapPair.first.first;
2015 MCSymbol *
const TOCEntryLabel = TOCMapPair.second;
2017 OutStreamer->emitLabel(TOCEntryLabel);
2019 TS->
emitTCEntry(*TOCEntryTarget, TOCMapPair.first.second);
2021 OutStreamer->emitSymbolValue(TOCEntryTarget, 4);
2025 PPCAsmPrinter::emitEndOfAsmFile(M);
2029void PPCLinuxAsmPrinter::emitFunctionBodyStart() {
2062 const bool UsesX2OrR2 = !MF->getRegInfo().use_empty(PPC::X2) ||
2063 !MF->getRegInfo().use_empty(PPC::R2);
2072 if (NonPCrelGEPRequired || PCrelGEPRequired) {
2077 OutStreamer->emitLabel(GlobalEntryLabel);
2083 const MCExpr *TOCDeltaExpr =
2085 GlobalEntryLabelExp, OutContext);
2091 .addExpr(TOCDeltaHi));
2097 .addExpr(TOCDeltaLo));
2100 const MCExpr *TOCOffsetDeltaExpr =
2102 GlobalEntryLabelExp, OutContext);
2106 .addExpr(TOCOffsetDeltaExpr)
2115 OutStreamer->emitLabel(LocalEntryLabel);
2118 const MCExpr *LocalOffsetExp =
2120 GlobalEntryLabelExp, OutContext);
2124 TS->
emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
2147 if (MF->getFrameInfo().hasCalls() || MF->getFrameInfo().hasTailCall() ||
2148 MF->hasInlineAsm() || (!PPCFI->
usesTOCBasePtr() && UsesX2OrR2)) {
2160void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
2169 OutStreamer->emitIntValue(0, 4);
2170 OutStreamer->emitIntValue(0, 8);
2174void PPCAIXAsmPrinter::emitLinkage(
const GlobalValue *GV,
2177 assert(MAI->hasVisibilityOnlyWithLinkage() &&
2178 "AIX's linkage directives take a visibility setting.");
2199 "InternalLinkage should not have other visibility setting.");
2211 if (!
TM.getIgnoreXCOFFVisibility()) {
2214 "Cannot not be both dllexport and non-default visibility");
2220 VisibilityAttr = MAI->getExportedVisibilityAttr();
2223 VisibilityAttr = MAI->getHiddenVisibilityAttr();
2226 VisibilityAttr = MAI->getProtectedVisibilityAttr();
2236 OutStreamer->emitXCOFFSymbolLinkageWithVisibility(GVSym, LinkageAttr,
2243 cast<MCSectionXCOFF>(getObjFileLowering().getSectionForFunctionDescriptor(
2252uint16_t PPCAIXAsmPrinter::getNumberOfVRSaved() {
2257 if (Subtarget.
isAIXABI() && Subtarget.hasAltivec() &&
2258 TM.getAIXExtendedAltivecABI()) {
2260 for (
unsigned Reg = PPC::V20;
Reg <= PPC::V31; ++
Reg)
2261 if (
MRI.isPhysRegModified(Reg))
2263 return PPC::V31 - Reg + 1;
2268void PPCAIXAsmPrinter::emitFunctionBodyEnd() {
2270 if (!
TM.getXCOFFTracebackTable())
2273 emitTracebackTable();
2281 (getNumberOfVRSaved() > 0)) {
2283 OutStreamer->switchSection(getObjFileLowering().getCompactUnwindSection());
2286 OutStreamer->emitLabel(EHInfoLabel);
2289 OutStreamer->emitInt32(0);
2291 const DataLayout &
DL = MMI->getModule()->getDataLayout();
2294 OutStreamer->emitValueToAlignment(
Align(PointerSize));
2296 OutStreamer->emitIntValue(0, PointerSize);
2297 OutStreamer->emitIntValue(0, PointerSize);
2298 OutStreamer->switchSection(MF->
getSection());
2302void PPCAIXAsmPrinter::emitTracebackTable() {
2306 OutStreamer->emitLabel(FuncEnd);
2308 OutStreamer->AddComment(
"Traceback table begin");
2310 OutStreamer->emitIntValueInHexWithPadding(0, 4 );
2315 auto EmitComment = [&]() {
2316 OutStreamer->AddComment(CommentOS.str());
2317 CommentString.
clear();
2322 OutStreamer->emitIntValueInHexWithPadding(
Value,
Size);
2326 CommentOS <<
"Version = " <<
Version;
2327 EmitCommentAndValue(Version, 1);
2337 CommentOS <<
"Language = "
2339 EmitCommentAndValue(LanguageIdentifier, 1);
2342 uint32_t FirstHalfOfMandatoryField = 0;
2353 for (
unsigned Reg = PPC::F0;
Reg <= PPC::F31; ++
Reg) {
2354 if (
MRI.isPhysRegUsed(Reg,
true)) {
2360#define GENBOOLCOMMENT(Prefix, V, Field) \
2361 CommentOS << (Prefix) << ((V) & (TracebackTable::Field##Mask) ? "+" : "-") \
2364#define GENVALUECOMMENT(PrefixAndName, V, Field) \
2365 CommentOS << (PrefixAndName) << " = " \
2366 << static_cast<unsigned>(((V) & (TracebackTable::Field##Mask)) >> \
2367 (TracebackTable::Field##Shift))
2370 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsOutOfLineEpilogOrPrologue);
2373 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, HasTraceBackTableOffset);
2374 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsInternalProcedure);
2377 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, HasControlledStorage);
2381 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, IsFloatingPointPresent);
2384 IsFloatingPointOperationLogOrAbortEnabled);
2387 OutStreamer->emitIntValueInHexWithPadding(
2388 (FirstHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
2396 if (FrameReg == (Subtarget->
isPPC64() ? PPC::X31 : PPC::R31))
2400 if (!MustSaveCRs.
empty())
2406 GENBOOLCOMMENT(
"", FirstHalfOfMandatoryField, IsInterruptHandler);
2407 GENBOOLCOMMENT(
", ", FirstHalfOfMandatoryField, IsFunctionNamePresent);
2411 OnConditionDirective);
2415 OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff),
2419 uint32_t SecondHalfOfMandatoryField = 0;
2426 for (
unsigned Reg = PPC::F14;
Reg <= PPC::F31; ++
Reg) {
2427 if (
MRI.isPhysRegModified(Reg)) {
2428 FPRSaved = PPC::F31 -
Reg + 1;
2434 GENBOOLCOMMENT(
"", SecondHalfOfMandatoryField, IsBackChainStored);
2436 GENVALUECOMMENT(
", NumOfFPRsSaved", SecondHalfOfMandatoryField, FPRSaved);
2438 OutStreamer->emitIntValueInHexWithPadding(
2439 (SecondHalfOfMandatoryField & 0xff000000) >> 24, 1);
2445 bool HasVectorInst =
false;
2446 for (
unsigned Reg = PPC::V0;
Reg <= PPC::V31; ++
Reg)
2447 if (
MRI.isPhysRegUsed(Reg,
true)) {
2449 HasVectorInst =
true;
2456 uint16_t NumOfVRSaved = getNumberOfVRSaved();
2457 bool ShouldEmitEHBlock =
2460 if (ShouldEmitEHBlock)
2466 unsigned GPRBegin = Subtarget->
isPPC64() ? PPC::X14 : PPC::R13;
2467 unsigned GPREnd = Subtarget->
isPPC64() ? PPC::X31 : PPC::R31;
2469 for (
unsigned Reg = GPRBegin;
Reg <= GPREnd; ++
Reg) {
2470 if (
MRI.isPhysRegModified(Reg)) {
2471 GPRSaved = GPREnd -
Reg + 1;
2479 GENBOOLCOMMENT(
"", SecondHalfOfMandatoryField, HasExtensionTable);
2481 GENVALUECOMMENT(
", NumOfGPRsSaved", SecondHalfOfMandatoryField, GPRSaved);
2483 OutStreamer->emitIntValueInHexWithPadding(
2484 (SecondHalfOfMandatoryField & 0x00ff0000) >> 16, 1);
2488 SecondHalfOfMandatoryField |=
2492 NumberOfFixedParms);
2494 OutStreamer->emitIntValueInHexWithPadding(
2495 (SecondHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
2503 SecondHalfOfMandatoryField |=
2508 NumberOfFloatingPointParms);
2509 GENBOOLCOMMENT(
", ", SecondHalfOfMandatoryField, HasParmsOnStack);
2511 OutStreamer->emitIntValueInHexWithPadding(SecondHalfOfMandatoryField & 0xff,
2517 if (NumberOfFixedParms || NumberOfFPParms) {
2523 ParmsTypeValue, NumberOfFixedParms, NumberOfFPParms,
2530 CommentOS <<
"Parameter type = " << ParmsType.
get();
2533 OutStreamer->emitIntValueInHexWithPadding(ParmsTypeValue,
2534 sizeof(ParmsTypeValue));
2537 OutStreamer->AddComment(
"Function size");
2539 MCSymbol *FuncSectSym = getObjFileLowering().getFunctionEntryPointSymbol(
2541 OutStreamer->emitAbsoluteSymbolDiff(FuncEnd, FuncSectSym, 4);
2553 int16_t NameLength =
Name.size();
2554 CommentOS <<
"Function name len = "
2555 <<
static_cast<unsigned int>(NameLength);
2556 EmitCommentAndValue(NameLength, 2);
2557 OutStreamer->AddComment(
"Function Name");
2558 OutStreamer->emitBytes(
Name);
2563 OutStreamer->AddComment(
"AllocaUsed");
2564 OutStreamer->emitIntValueInHex(AllocReg,
sizeof(AllocReg));
2597 OutStreamer->emitIntValueInHexWithPadding((VRData & 0xff00) >> 8, 1);
2602 OutStreamer->emitIntValueInHexWithPadding(VRData & 0x00ff, 1);
2610 CommentOS <<
"Vector Parameter type = " << VecParmsType.
get();
2613 OutStreamer->emitIntValueInHexWithPadding(VecParmTypeValue,
2614 sizeof(VecParmTypeValue));
2616 CommentOS <<
"Padding";
2617 EmitCommentAndValue(0, 2);
2620 uint8_t ExtensionTableFlag = 0;
2622 if (ShouldEmitEHBlock)
2623 ExtensionTableFlag |= ExtendedTBTableFlag::TB_EH_INFO;
2626 ExtensionTableFlag |= ExtendedTBTableFlag::TB_SSP_CANARY;
2628 CommentOS <<
"ExtensionTableFlag = "
2630 EmitCommentAndValue(ExtensionTableFlag,
sizeof(ExtensionTableFlag));
2633 if (ExtensionTableFlag & ExtendedTBTableFlag::TB_EH_INFO) {
2634 auto &Ctx = OutStreamer->getContext();
2637 MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(EHInfoSym, TOCType_EHBlock);
2639 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
2640 ->getQualNameSymbol();
2646 OutStreamer->emitValueToAlignment(
Align(4));
2647 OutStreamer->AddComment(
"EHInfo Table");
2648 OutStreamer->emitValue(Exp,
DL.getPointerSize());
2650#undef GENBOOLCOMMENT
2651#undef GENVALUECOMMENT
2660 .
Case(
"llvm.used",
true)
2662 .
Case(
"llvm.compiler.used",
true)
2668 .
Cases(
"llvm.global_ctors",
"llvm.global_dtors",
true)
2673 if (
auto *GA = dyn_cast<GlobalAlias>(
C))
2674 return getAliasOffset(GA->getAliasee());
2675 if (
auto *CE = dyn_cast<ConstantExpr>(
C)) {
2677 const MCBinaryExpr *CBE = dyn_cast<MCBinaryExpr>(LowC);
2682 auto *
RHS = dyn_cast<MCConstantExpr>(CBE->
getRHS());
2685 return RHS->getValue();
2695 "GlobalVariables with an alignment requirement stricter than TOC entry "
2696 "size not supported by the toc data transformation.");
2699 assert(GVType->
isSized() &&
"A GlobalVariable's size must be known to be "
2700 "supported by the toc data transformation.");
2704 "A GlobalVariable with size larger than a TOC entry is not currently "
2705 "supported by the toc data transformation.");
2708 "currently supported by the toc data transformation.");
2711void PPCAIXAsmPrinter::emitGlobalVariable(
const GlobalVariable *GV) {
2721 TOCDataGlobalVars.push_back(GV);
2725 emitGlobalVariableHelper(GV);
2728void PPCAIXAsmPrinter::emitGlobalVariableHelper(
const GlobalVariable *GV) {
2730 "Unhandled intrinsic global variable.");
2738 emitLinkage(GV, GVSym);
2742 SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV,
TM);
2746 "not supported yet.");
2753 OutStreamer->getCommentOS() <<
'\n';
2758 getObjFileLowering().SectionForGlobal(GV, GVKind,
TM));
2761 OutStreamer->switchSection(Csect);
2774 OutStreamer->emitZeros(
Size);
2777 "BSS local toc-data already handled and TLS variables "
2778 "incompatible with XMC_TD");
2779 OutStreamer->emitXCOFFLocalCommonSymbol(
2783 OutStreamer->emitCommonSymbol(GVSym,
Size, Alignment);
2791 emitLinkage(GV, EmittedInitSym);
2793 emitLinkage(GA, getSymbol(GA));
2795 emitAlignment(getGVAlignment(GV,
DL), GV);
2799 if (!
TM.getDataSections() || GV->hasSection())
2800 OutStreamer->emitLabel(EmittedInitSym);
2803 if (!GOAliasMap[GV].
size()) {
2804 emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
2810 AliasMapTy AliasList;
2812 AliasList[getAliasOffset(GA->getAliasee())].push_back(GA);
2815 emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer(),
2819void PPCAIXAsmPrinter::emitFunctionDescriptor() {
2821 const unsigned PointerSize =
DL.getPointerSizeInBits() == 64 ? 8 : 4;
2825 OutStreamer->switchSection(
2826 cast<MCSymbolXCOFF>(CurrentFnDescSym)->getRepresentedCsect());
2830 OutStreamer->emitLabel(getSymbol(Alias));
2837 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
2838 ->getQualNameSymbol();
2842 OutStreamer->emitIntValue(0, PointerSize);
2844 OutStreamer->switchSection(Current.first, Current.second);
2847void PPCAIXAsmPrinter::emitFunctionEntryLabel() {
2850 if (!
TM.getFunctionSections())
2851 PPCAsmPrinter::emitFunctionEntryLabel();
2855 OutStreamer->emitLabel(
2856 getObjFileLowering().getFunctionEntryPointSymbol(Alias,
TM));
2859void PPCAIXAsmPrinter::emitPGORefs(
Module &M) {
2860 if (!OutContext.hasXCOFFSection(
2871 bool HasNonZeroLengthPrfCntsSection =
false;
2874 if (GV.hasSection() && GV.getSection().equals(
"__llvm_prf_cnts") &&
2875 DL.getTypeAllocSize(GV.getValueType()) > 0) {
2876 HasNonZeroLengthPrfCntsSection =
true;
2880 if (HasNonZeroLengthPrfCntsSection) {
2881 MCSection *CntsSection = OutContext.getXCOFFSection(
2886 OutStreamer->switchSection(CntsSection);
2887 if (OutContext.hasXCOFFSection(
2890 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_data[RW]");
2891 OutStreamer->emitXCOFFRefDirective(S);
2893 if (OutContext.hasXCOFFSection(
2896 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_names[RO]");
2897 OutStreamer->emitXCOFFRefDirective(S);
2899 if (OutContext.hasXCOFFSection(
2902 MCSymbol *S = OutContext.getOrCreateSymbol(
"__llvm_prf_vnds[RW]");
2903 OutStreamer->emitXCOFFRefDirective(S);
2908void PPCAIXAsmPrinter::emitEndOfAsmFile(
Module &M) {
2911 if (
M.empty() && TOCDataGlobalVars.empty())
2917 OutStreamer->switchSection(getObjFileLowering().getTOCBaseSection());
2922 for (
auto &
I : TOC) {
2927 if (
I.first.second == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM) {
2931 Name += cast<MCSymbolXCOFF>(
I.first.first)->getSymbolTableName();
2933 TCEntry = cast<MCSectionXCOFF>(
2934 getObjFileLowering().getSectionForTOCEntry(S,
TM));
2936 TCEntry = cast<MCSectionXCOFF>(
2937 getObjFileLowering().getSectionForTOCEntry(
I.first.first,
TM));
2939 OutStreamer->switchSection(TCEntry);
2941 OutStreamer->emitLabel(
I.second);
2948 for (
const auto *GV : TOCDataGlobalVars) {
2949 if (!GV->hasCommonLinkage())
2950 emitGlobalVariableHelper(GV);
2952 for (
const auto *GV : TOCDataGlobalVars) {
2953 if (GV->hasCommonLinkage())
2954 emitGlobalVariableHelper(GV);
2958bool PPCAIXAsmPrinter::doInitialization(
Module &M) {
2959 const bool Result = PPCAsmPrinter::doInitialization(M);
2961 auto setCsectAlignment = [
this](
const GlobalObject *GO) {
2963 if (GO->isDeclarationForLinker())
2966 SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO,
TM);
2968 getObjFileLowering().SectionForGlobal(GO, GOKind,
TM));
2970 Align GOAlign = getGVAlignment(GO, GO->getParent()->getDataLayout());
2978 auto DL =
M.getDataLayout();
2979 for (
const auto &
G :
M.globals()) {
2980 if (
G.isThreadLocal() && !
G.isDeclaration()) {
2981 TLSVarAddress =
alignTo(TLSVarAddress, getGVAlignment(&
G,
DL));
2982 TLSVarsToAddressMapping[&
G] = TLSVarAddress;
2983 TLSVarAddress +=
DL.getTypeAllocSize(
G.getValueType());
2990 for (
const auto &
G :
M.globals()) {
2997 if (FormatIndicatorAndUniqueModId.empty()) {
2999 if (UniqueModuleId !=
"")
3003 FormatIndicatorAndUniqueModId =
"clang_" + UniqueModuleId.substr(1);
3008 std::chrono::duration_cast<std::chrono::nanoseconds>(
3009 std::chrono::steady_clock::now().time_since_epoch())
3011 FormatIndicatorAndUniqueModId =
3014 llvm::itostr(CurTime);
3018 emitSpecialLLVMGlobal(&
G);
3022 setCsectAlignment(&
G);
3023 std::optional<CodeModel::Model> OptionalCodeModel =
G.getCodeModel();
3024 if (OptionalCodeModel)
3026 *OptionalCodeModel);
3029 for (
const auto &
F : M)
3030 setCsectAlignment(&
F);
3033 for (
const auto &Alias :
M.aliases()) {
3037 "alias without a base object is not yet supported on AIX");
3041 "\n\tAlias attribute for " +
3042 Alias.getGlobalIdentifier() +
3043 " is invalid because " + Aliasee->
getName() +
3049 dyn_cast_or_null<GlobalVariable>(Alias.getAliaseeObject());
3051 std::optional<CodeModel::Model> OptionalCodeModel = GVar->
getCodeModel();
3052 if (OptionalCodeModel)
3054 *OptionalCodeModel);
3057 GOAliasMap[Aliasee].push_back(&Alias);
3064 switch (
MI->getOpcode()) {
3071 if (
MI->getNumOperands() < 5)
3077 MCSymbol *TempSym = OutContext.createNamedTempSymbol();
3078 OutStreamer->emitLabel(TempSym);
3079 OutStreamer->emitXCOFFExceptDirective(CurrentFnSym, TempSym,
3081 Subtarget->
isPPC64() ?
MI->getMF()->getInstructionCount() * 8 :
3082 MI->getMF()->getInstructionCount() * 4,
3083 MMI->hasDebugInfo());
3086 case PPC::GETtlsMOD32AIX:
3087 case PPC::GETtlsMOD64AIX:
3088 case PPC::GETtlsTpointer32AIX:
3089 case PPC::GETtlsADDR64AIX:
3090 case PPC::GETtlsADDR32AIX: {
3095 ExtSymSDNodeSymbols.insert(TlsGetAddr);
3105 cast<MCSymbolXCOFF>(OutContext.getOrCreateSymbol(MO.
getSymbolName()));
3106 ExtSymSDNodeSymbols.insert(S);
3112 case PPC::BL8_NOP_TLS:
3119 case PPC::TAILBCTR8:
3120 if (
MI->getOperand(0).isSymbol())
3133 MCInstBuilder(PPC::ORI).addReg(PPC::R0).addReg(PPC::R0).addImm(0));
3136 return PPCAsmPrinter::emitInstruction(
MI);
3139bool PPCAIXAsmPrinter::doFinalization(
Module &M) {
3141 if (!MAI->usesDwarfFileAndLocDirectives() && MMI->hasDebugInfo())
3142 OutStreamer->doFinalizationAtSectionEnd(
3143 OutStreamer->getContext().getObjectFileInfo()->getTextSection());
3147 return PPCAsmPrinter::doFinalization(M);
3151 if (P < 0 || P > 65535)
3158 return 20 + (
P - 20) * 16;
3161 return 1004 + (
P - 81);
3164 return 2047 + (
P - 1124) * 33878;
3166 return 2147482625u + (
P - 64512);
3185 std::string PrioritySuffix;
3189 return PrioritySuffix;
3192void PPCAIXAsmPrinter::emitXXStructorList(
const DataLayout &
DL,
3193 const Constant *List,
bool IsCtor) {
3195 preprocessXXStructorList(
DL, List, Structors);
3196 if (Structors.
empty())
3200 for (Structor &S : Structors) {
3201 if (
const ConstantExpr *CE = dyn_cast<ConstantExpr>(S.Func))
3202 S.Func =
CE->getOperand(0);
3210 cast<Function>(S.Func));
3214void PPCAIXAsmPrinter::emitTTypeReference(
const GlobalValue *GV,
3215 unsigned Encoding) {
3217 TOCEntryType GlobalType = TOCType_GlobalInternal;
3222 GlobalType = TOCType_GlobalExternal;
3224 MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(TypeInfoSym, GlobalType);
3226 cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
3227 ->getQualNameSymbol();
3228 auto &Ctx = OutStreamer->getContext();
3232 OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
3234 OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
3241 std::unique_ptr<MCStreamer> &&Streamer) {
3243 return new PPCAIXAsmPrinter(tm, std::move(Streamer));
3245 return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
3248void PPCAIXAsmPrinter::emitModuleCommandLines(
Module &M) {
3249 const NamedMDNode *NMD =
M.getNamedMetadata(
"llvm.commandline");
3257 assert(
N->getNumOperands() == 1 &&
3258 "llvm.commandline metadata entry can have only one operand");
3259 const MDString *MDS = cast<MDString>(
N->getOperand(0));
3262 RSOS <<
"@(#)opt " << MDS->
getString() <<
"\n";
3265 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 defines the SmallPtrSet class.
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.
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.
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
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
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
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)
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