62 unsigned size()
const {
return IDs.
size(); }
63 std::pair<unsigned, bool> &operator[](
const Value *V) {
return IDs[V]; }
64 std::pair<unsigned, bool>
lookup(
const Value *V)
const {
67 void index(
const Value *V) {
69 unsigned ID = IDs.size() + 1;
76 if (OM.lookup(V).first)
79 if (
const Constant *
C = dyn_cast<Constant>(V))
80 if (
C->getNumOperands() && !isa<GlobalValue>(
C))
81 for (
const Value *
Op :
C->operands())
82 if (!isa<BasicBlock>(
Op) && !isa<GlobalValue>(
Op))
96 if (
G.hasInitializer())
97 if (!isa<GlobalValue>(
G.getInitializer()))
102 if (!isa<GlobalValue>(
A.getAliasee()))
107 if (!isa<GlobalValue>(
I.getResolver()))
112 for (
const Use &U :
F.operands())
113 if (!isa<GlobalValue>(U.get()))
118 if (
F.isDeclaration())
126 for (
const Value *
Op :
I.operands())
127 if ((isa<Constant>(*
Op) && !isa<GlobalValue>(*
Op)) ||
138 unsigned ID,
const OrderMap &OM,
141 typedef std::pair<const Use *, unsigned> Entry;
145 if (OM.lookup(U.getUser()).first)
153 !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
154 if (
auto *BA = dyn_cast<BlockAddress>(V))
155 ID = OM.lookup(BA->getBasicBlock()).first;
156 std::sort(List.
begin(), List.
end(), [&](
const Entry &
L,
const Entry &R) {
157 const Use *LU = L.first;
158 const Use *RU = R.first;
162 auto LID = OM.lookup(LU->getUser()).first;
163 auto RID = OM.lookup(RU->getUser()).first;
183 return LU->getOperandNo() < RU->getOperandNo();
184 return LU->getOperandNo() > RU->getOperandNo();
189 [](
const Entry &
L,
const Entry &R) {
return L.second < R.second; }))
194 Stack.emplace_back(V, F, List.
size());
195 assert(List.
size() == Stack.back().Shuffle.size() &&
"Wrong size");
196 for (
size_t I = 0,
E = List.
size();
I !=
E; ++
I)
197 Stack.back().Shuffle[
I] = List[
I].second;
202 auto &IDPair = OM[V];
203 assert(IDPair.first &&
"Unmapped value");
209 IDPair.second =
true;
214 if (
const Constant *
C = dyn_cast<Constant>(V))
215 if (
C->getNumOperands())
216 for (
const Value *
Op :
C->operands())
217 if (isa<Constant>(
Op))
235 if (
F.isDeclaration())
243 for (
const Value *
Op :
I.operands())
244 if (isa<Constant>(*
Op) || isa<InlineAsm>(*Op))
261 if (
G.hasInitializer())
268 for (
const Use &U :
F.operands())
275 if (
const Argument *MA = dyn_cast<Argument>(V))
276 return MA->getParent() ? MA->getParent()->getParent() :
nullptr;
278 if (
const BasicBlock *BB = dyn_cast<BasicBlock>(V))
279 return BB->getParent() ? BB->getParent()->getParent() :
nullptr;
282 const Function *M =
I->getParent() ?
I->getParent()->getParent() :
nullptr;
286 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V))
287 return GV->getParent();
289 if (
const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
291 if (isa<Instruction>(U))
302 default: Out <<
"cc" << cc;
break;
342 for (
unsigned i = 0, e = Name.
size();
i != e; ++
i) {
343 unsigned char C = Name[
i];
344 if (isprint(C) && C !=
'\\' && C !=
'"')
347 Out << '\\' << hexdigit(C >> 4) <<
hexdigit(C & 0x0F);
363 bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
365 for (
unsigned i = 0, e = Name.
size();
i != e; ++
i) {
370 unsigned char C = Name[
i];
371 if (!isalnum(static_cast<unsigned char>(C)) && C !=
'-' && C !=
'.' &&
425 TypePrinting(
const TypePrinting &) =
delete;
426 void operator=(
const TypePrinting&) =
delete;
435 TypePrinting() =
default;
437 void incorporateTypes(
const Module &M);
445 void TypePrinting::incorporateTypes(
const Module &M) {
446 NamedTypes.run(M,
false);
450 unsigned NextNumber = 0;
452 std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(),
I,
E;
453 for (
I = NamedTypes.begin(), E = NamedTypes.end();
I !=
E; ++
I) {
461 NumberedTypes[STy] = NextNumber++;
466 NamedTypes.erase(NextToUse, NamedTypes.end());
510 return printStructBody(STy, OS);
516 if (I != NumberedTypes.
end())
517 OS <<
'%' << I->second;
519 OS <<
"%\"type " << STy <<
'\"';
545 llvm_unreachable("Invalid TypeID");
548 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
549 if (STy->isOpaque()) {
557 if (STy->getNumElements() == 0) {
560 StructType::element_iterator I = STy->element_begin();
563 for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
575 //===----------------------------------------------------------------------===//
576 // SlotTracker Class: Enumerate slot numbers for unnamed values
577 //===----------------------------------------------------------------------===//
583 typedef DenseMap<const Value*, unsigned> ValueMap;
587 const Module* TheModule;
590 const Function* TheFunction;
591 bool FunctionProcessed;
592 bool ShouldInitializeAllMetadata;
603 DenseMap<const MDNode*, unsigned> mdnMap;
607 DenseMap<AttributeSet, unsigned> asMap;
615 explicit SlotTracker(const Module *M,
616 bool ShouldInitializeAllMetadata = false);
622 explicit SlotTracker(const Function *F,
623 bool ShouldInitializeAllMetadata = false);
627 int getLocalSlot(const Value *V);
628 int getGlobalSlot(const GlobalValue *V);
629 int getMetadataSlot(const MDNode *N);
630 int getAttributeGroupSlot(AttributeSet AS);
634 void incorporateFunction(const Function *F) {
636 FunctionProcessed = false;
639 const Function *getFunction() const { return TheFunction; }
644 void purgeFunction();
647 typedef DenseMap<const MDNode*, unsigned>::iterator mdn_iterator;
648 mdn_iterator mdn_begin() { return mdnMap.begin(); }
649 mdn_iterator mdn_end() { return mdnMap.end(); }
650 unsigned mdn_size() const { return mdnMap.size(); }
651 bool mdn_empty() const { return mdnMap.empty(); }
654 typedef DenseMap<AttributeSet, unsigned>::iterator as_iterator;
655 as_iterator as_begin() { return asMap.begin(); }
656 as_iterator as_end() { return asMap.end(); }
657 unsigned as_size() const { return asMap.size(); }
658 bool as_empty() const { return asMap.empty(); }
661 inline void initialize();
663 // Implementation Details
666 void CreateModuleSlot(const GlobalValue *V);
669 void CreateMetadataSlot(const MDNode *N);
672 void CreateFunctionSlot(const Value *V);
675 void CreateAttributeSetSlot(AttributeSet AS);
679 void processModule();
682 void processFunction();
685 void processGlobalObjectMetadata(const GlobalObject &GO);
688 void processFunctionMetadata(const Function &F);
691 void processInstructionMetadata(const Instruction &I);
693 SlotTracker(const SlotTracker &) = delete;
694 void operator=(const SlotTracker &) = delete;
698 ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
700 : M(M), F(F), Machine(&Machine) {}
702 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
703 bool ShouldInitializeAllMetadata)
704 : ShouldCreateStorage(M),
705 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
707 ModuleSlotTracker::~ModuleSlotTracker() {}
709 SlotTracker *ModuleSlotTracker::getMachine() {
710 if (!ShouldCreateStorage)
713 ShouldCreateStorage = false;
715 llvm::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
716 Machine = MachineStorage.get();
720 void ModuleSlotTracker::incorporateFunction(const Function &F) {
721 // Using getMachine() may lazily create the slot tracker.
725 // Nothing to do if this is the right function already.
729 Machine->purgeFunction();
730 Machine->incorporateFunction(&F);
734 int ModuleSlotTracker::getLocalSlot(const Value *V) {
735 assert(F && "No function incorporated");
736 return Machine->getLocalSlot(V);
739 static SlotTracker *createSlotTracker(const Value *V) {
740 if (const Argument *FA = dyn_cast<Argument>(V))
741 return new SlotTracker(FA->getParent());
743 if (const Instruction *I = dyn_cast<Instruction>(V))
745 return new SlotTracker(I->getParent()->getParent());
747 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
748 return new SlotTracker(BB->getParent());
750 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
751 return new SlotTracker(GV->getParent());
753 if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
754 return new SlotTracker(GA->getParent());
756 if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
757 return new SlotTracker(GIF->getParent());
759 if (const Function *Func = dyn_cast<Function>(V))
760 return new SlotTracker(Func);
766 #define ST_DEBUG(X) dbgs() << X
771 // Module level constructor. Causes the contents of the Module (sans functions)
772 // to be added to the slot table.
773 SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
774 : TheModule(M), TheFunction(nullptr), FunctionProcessed(false),
775 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
776 fNext(0), mdnNext(0), asNext(0) {}
778 // Function level constructor. Causes the contents of the Module and the one
779 // function provided to be added to the slot table.
780 SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
781 : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
782 FunctionProcessed(false),
783 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), mNext(0),
784 fNext(0), mdnNext(0), asNext(0) {}
786 inline void SlotTracker::initialize() {
789 TheModule = nullptr; ///< Prevent re-processing next time we're called.
792 if (TheFunction && !FunctionProcessed)
798 void SlotTracker::processModule() {
804 CreateModuleSlot(&Var);
805 processGlobalObjectMetadata(Var);
810 CreateModuleSlot(&
A);
815 CreateModuleSlot(&I);
820 for (
unsigned i = 0, e = NMD.getNumOperands();
i != e; ++
i)
821 CreateMetadataSlot(NMD.getOperand(
i));
827 CreateModuleSlot(&
F);
829 if (ShouldInitializeAllMetadata)
830 processFunctionMetadata(
F);
836 CreateAttributeSetSlot(FnAttrs);
843 void SlotTracker::processFunction() {
844 ST_DEBUG(
"begin processFunction!\n");
848 if (!ShouldInitializeAllMetadata)
849 processFunctionMetadata(*TheFunction);
853 AE = TheFunction->
arg_end(); AI != AE; ++AI)
855 CreateFunctionSlot(&*AI);
857 ST_DEBUG(
"Inserting Instructions:\n");
860 for (
auto &BB : *TheFunction) {
862 CreateFunctionSlot(&BB);
865 if (!I.getType()->isVoidTy() && !I.hasName())
866 CreateFunctionSlot(&I);
870 if (
const CallInst *CI = dyn_cast<CallInst>(&I)) {
872 AttributeSet Attrs = CI->getAttributes().getFnAttributes();
874 CreateAttributeSetSlot(Attrs);
875 }
else if (
const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
877 AttributeSet Attrs = II->getAttributes().getFnAttributes();
879 CreateAttributeSetSlot(Attrs);
884 FunctionProcessed =
true;
889 void SlotTracker::processGlobalObjectMetadata(
const GlobalObject &GO) {
893 CreateMetadataSlot(MD.second);
896 void SlotTracker::processFunctionMetadata(
const Function &
F) {
897 processGlobalObjectMetadata(F);
900 processInstructionMetadata(I);
904 void SlotTracker::processInstructionMetadata(
const Instruction &I) {
906 if (
const CallInst *CI = dyn_cast<CallInst>(&I))
907 if (
Function *F = CI->getCalledFunction())
908 if (F->isIntrinsic())
910 if (
auto *V = dyn_cast_or_null<MetadataAsValue>(
Op))
911 if (
MDNode *
N = dyn_cast<MDNode>(V->getMetadata()))
912 CreateMetadataSlot(
N);
918 CreateMetadataSlot(MD.second);
927 TheFunction =
nullptr;
928 FunctionProcessed =
false;
939 return MI == mMap.
end() ? -1 : (int)MI->second;
949 return MI == mdnMap.end() ? -1 : (int)MI->second;
955 assert(!isa<Constant>(V) &&
"Can't get a constant or global slot with this!");
961 return FI == fMap.
end() ? -1 : (int)FI->second;
970 return AI == asMap.
end() ? -1 : (int)AI->second;
974 void SlotTracker::CreateModuleSlot(
const GlobalValue *V) {
975 assert(V &&
"Can't insert a null Value into SlotTracker!");
979 unsigned DestSlot = mNext++;
982 ST_DEBUG(
" Inserting value [" << V->
getType() <<
"] = " << V <<
" slot=" <<
985 ST_DEBUG((isa<GlobalVariable>(V) ?
'G' :
986 (isa<Function>(V) ?
'F' :
987 (isa<GlobalAlias>(V) ?
'A' :
988 (isa<GlobalIFunc>(V) ?
'I' :
'o')))) <<
"]\n");
992 void SlotTracker::CreateFunctionSlot(
const Value *V) {
995 unsigned DestSlot = fNext++;
999 ST_DEBUG(
" Inserting value [" << V->
getType() <<
"] = " << V <<
" slot=" <<
1000 DestSlot <<
" [o]\n");
1004 void SlotTracker::CreateMetadataSlot(
const MDNode *
N) {
1005 assert(N &&
"Can't insert a null Value into SlotTracker!");
1007 unsigned DestSlot = mdnNext;
1008 if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1015 CreateMetadataSlot(
Op);
1018 void SlotTracker::CreateAttributeSetSlot(
AttributeSet AS) {
1020 "Doesn't need a slot!");
1023 if (I != asMap.
end())
1026 unsigned DestSlot = asNext++;
1027 asMap[AS] = DestSlot;
1035 TypePrinting *TypePrinter,
1040 TypePrinting *TypePrinter,
1042 bool FromValue =
false);
1047 default: Out <<
" <unknown operation " << Op <<
">";
break;
1063 if (
const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
1065 if (FPO->hasUnsafeAlgebra())
1068 if (FPO->hasNoNaNs())
1070 if (FPO->hasNoInfs())
1072 if (FPO->hasNoSignedZeros())
1074 if (FPO->hasAllowReciprocal())
1080 dyn_cast<OverflowingBinaryOperator>(U)) {
1081 if (OBO->hasNoUnsignedWrap())
1083 if (OBO->hasNoSignedWrap())
1086 dyn_cast<PossiblyExactOperator>(U)) {
1090 if (
GEP->isInBounds())
1096 TypePrinting &TypePrinter,
1099 if (
const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1100 if (CI->getType()->isIntegerTy(1)) {
1101 Out << (CI->getZExtValue() ?
"true" :
"false");
1104 Out << CI->getValue();
1108 if (
const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1118 bool isInf = CFP->getValueAPF().isInfinity();
1119 bool isNaN = CFP->getValueAPF().isNaN();
1120 if (!isInf && !isNaN) {
1121 double Val = isDouble ? CFP->getValueAPF().convertToDouble() :
1122 CFP->getValueAPF().convertToFloat();
1130 if ((StrVal[0] >=
'0' && StrVal[0] <=
'9') ||
1131 ((StrVal[0] ==
'-' || StrVal[0] ==
'+') &&
1132 (StrVal[1] >=
'0' && StrVal[1] <=
'9'))) {
1144 static_assert(
sizeof(
double) ==
sizeof(uint64_t),
1145 "assuming that double is 64 bits!");
1146 APFloat apf = CFP->getValueAPF();
1159 APInt API = CFP->getValueAPF().bitcastToAPInt();
1188 if (isa<ConstantAggregateZero>(CV)) {
1189 Out <<
"zeroinitializer";
1193 if (
const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1194 Out <<
"blockaddress(";
1204 if (
const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1205 Type *ETy = CA->getType()->getElementType();
1207 TypePrinter.print(ETy, Out);
1212 for (
unsigned i = 1, e = CA->getNumOperands();
i != e; ++
i) {
1214 TypePrinter.print(ETy, Out);
1226 if (CA->isString()) {
1233 Type *ETy = CA->getType()->getElementType();
1235 TypePrinter.print(ETy, Out);
1240 for (
unsigned i = 1, e = CA->getNumElements();
i != e; ++
i) {
1242 TypePrinter.print(ETy, Out);
1253 if (CS->getType()->isPacked())
1256 unsigned N = CS->getNumOperands();
1259 TypePrinter.print(CS->getOperand(0)->getType(), Out);
1265 for (
unsigned i = 1;
i <
N;
i++) {
1267 TypePrinter.print(CS->getOperand(
i)->getType(), Out);
1277 if (CS->getType()->isPacked())
1282 if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
1285 TypePrinter.print(ETy, Out);
1291 TypePrinter.print(ETy, Out);
1300 if (isa<ConstantPointerNull>(CV)) {
1305 if (isa<ConstantTokenNone>(CV)) {
1310 if (isa<UndefValue>(CV)) {
1315 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1316 Out << CE->getOpcodeName();
1317 WriteOptimizationInfo(Out, CE);
1318 if (CE->isCompare())
1319 Out << ' ' << CmpInst::getPredicateName(
1320 static_cast<CmpInst::Predicate>(CE->getPredicate()));
1323 Optional<unsigned> InRangeOp;
1324 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1325 TypePrinter.print(GEP->getSourceElementType(), Out);
1327 InRangeOp = GEP->getInRangeIndex();
1332 for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
1333 if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
1335 TypePrinter.print((*OI)->getType(), Out);
1337 WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
1338 if (OI+1 != CE->op_end())
1342 if (CE->hasIndices()) {
1343 ArrayRef<unsigned> Indices = CE->getIndices();
1344 for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1345 Out << ", " << Indices[i];
1350 TypePrinter.print(CE->getType(), Out);
1357 Out << "<placeholder or erroneous Constant>";
1360 static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1361 TypePrinting *TypePrinter, SlotTracker *Machine,
1362 const Module *Context) {
1364 for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
1365 const Metadata *MD = Node->getOperand(mi);
1368 else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1369 Value *V = MDV->getValue();
1370 TypePrinter->print(V->getType(), Out);
1372 WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
1374 WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1384 struct FieldSeparator {
1387 FieldSeparator(const char *Sep = ", ") : Skip(true), Sep(Sep) {}
1389 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
1394 return OS << FS.Sep;
1396 struct MDFieldPrinter {
1399 TypePrinting *TypePrinter;
1400 SlotTracker *Machine;
1401 const Module *Context;
1403 explicit MDFieldPrinter(raw_ostream &Out)
1404 : Out(Out), TypePrinter(nullptr), Machine(nullptr), Context(nullptr) {}
1405 MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
1406 SlotTracker *Machine, const Module *Context)
1407 : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
1409 void printTag(const DINode *N);
1410 void printMacinfoType(const DIMacroNode *N);
1411 void printChecksumKind(const DIFile *N);
1412 void printString(StringRef Name, StringRef Value,
1413 bool ShouldSkipEmpty = true);
1414 void printMetadata(StringRef Name, const Metadata *MD,
1415 bool ShouldSkipNull = true);
1416 template <class IntTy>
1417 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1418 void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
1419 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1420 template <class IntTy, class Stringifier>
1421 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1422 bool ShouldSkipZero = true);
1423 void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1427 void MDFieldPrinter::printTag(const DINode *N) {
1428 Out << FS << "tag: ";
1429 auto Tag = dwarf::TagString(N->getTag());
1436 void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1437 Out << FS << "type: ";
1438 auto Type = dwarf::MacinfoString(N->getMacinfoType());
1442 Out << N->getMacinfoType();
1445 void MDFieldPrinter::printChecksumKind(const DIFile *N) {
1446 if (N->getChecksumKind() == DIFile::CSK_None)
1447 // Skip CSK_None checksum kind.
1449 Out << FS << "checksumkind: " << N->getChecksumKindAsString();
1452 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1453 bool ShouldSkipEmpty) {
1454 if (ShouldSkipEmpty && Value.empty())
1457 Out << FS << Name << ": \"";
1458 PrintEscapedString(Value, Out);
1462 static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1463 TypePrinting *TypePrinter,
1464 SlotTracker *Machine,
1465 const Module *Context) {
1470 WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1473 void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1474 bool ShouldSkipNull) {
1475 if (ShouldSkipNull && !MD)
1478 Out << FS << Name << ": ";
1479 writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1482 template <class IntTy>
1483 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1484 if (ShouldSkipZero && !Int)
1487 Out << FS << Name << ": " << Int;
1490 void MDFieldPrinter::printBool(StringRef Name, bool Value,
1491 Optional<bool> Default) {
1492 if (Default && Value == *Default)
1494 Out << FS << Name << ": " << (Value ? "true" : "false");
1497 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1501 Out << FS << Name << ": ";
1503 SmallVector<DINode::DIFlags, 8> SplitFlags;
1504 auto Extra = DINode::splitFlags(Flags, SplitFlags);
1506 FieldSeparator FlagsFS(" | ");
1507 for (auto F : SplitFlags) {
1508 auto StringF = DINode::getFlagString(F);
1509 assert(!StringF.empty() && "Expected valid flag");
1510 Out << FlagsFS << StringF;
1512 if (Extra || SplitFlags.empty())
1513 Out << FlagsFS << Extra;
1516 void MDFieldPrinter::printEmissionKind(StringRef Name,
1517 DICompileUnit::DebugEmissionKind EK) {
1518 Out << FS << Name << ": " << DICompileUnit::EmissionKindString(EK);
1522 template <class IntTy, class Stringifier>
1523 void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
1524 Stringifier toString, bool ShouldSkipZero) {
1528 Out << FS << Name << ": ";
1529 auto S = toString(Value);
1536 static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
1537 TypePrinting *TypePrinter, SlotTracker *Machine,
1538 const Module *Context) {
1539 Out << "!GenericDINode(";
1540 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1541 Printer.printTag(N);
1542 Printer.printString("header", N->getHeader());
1543 if (N->getNumDwarfOperands()) {
1544 Out << Printer.FS << "operands: {";
1546 for (auto &I : N->dwarf_operands()) {
1548 writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
1555 static void writeDILocation(raw_ostream &Out, const DILocation *DL,
1556 TypePrinting *TypePrinter, SlotTracker *Machine,
1557 const Module *Context) {
1558 Out << "!DILocation(";
1559 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1560 // Always output the line, since 0 is a relevant and important value for it.
1561 Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
1562 Printer.printInt("column", DL->getColumn());
1563 Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
1564 Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
1568 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
1569 TypePrinting *, SlotTracker *, const Module *) {
1570 Out << "!DISubrange(";
1571 MDFieldPrinter Printer(Out);
1572 Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
1573 Printer.printInt("lowerBound", N->getLowerBound());
1577 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
1578 TypePrinting *, SlotTracker *, const Module *) {
1579 Out << "!DIEnumerator(";
1580 MDFieldPrinter Printer(Out);
1581 Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
1582 Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
1586 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
1587 TypePrinting *, SlotTracker *, const Module *) {
1588 Out << "!DIBasicType(";
1589 MDFieldPrinter Printer(Out);
1590 if (N->getTag() != dwarf::DW_TAG_base_type)
1591 Printer.printTag(N);
1592 Printer.printString("name", N->getName());
1593 Printer.printInt("size", N->getSizeInBits());
1594 Printer.printInt("align", N->getAlignInBits());
1595 Printer.printDwarfEnum("encoding", N->getEncoding(),
1596 dwarf::AttributeEncodingString);
1600 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
1601 TypePrinting *TypePrinter, SlotTracker *Machine,
1602 const Module *Context) {
1603 Out << "!DIDerivedType(";
1604 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1605 Printer.printTag(N);
1606 Printer.printString("name", N->getName());
1607 Printer.printMetadata("scope", N->getRawScope());
1608 Printer.printMetadata("file", N->getRawFile());
1609 Printer.printInt("line", N->getLine());
1610 Printer.printMetadata("baseType", N->getRawBaseType(),
1611 /* ShouldSkipNull */ false);
1612 Printer.printInt("size", N->getSizeInBits());
1613 Printer.printInt("align", N->getAlignInBits());
1614 Printer.printInt("offset", N->getOffsetInBits());
1615 Printer.printDIFlags("flags", N->getFlags());
1616 Printer.printMetadata("extraData", N->getRawExtraData());
1620 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
1621 TypePrinting *TypePrinter,
1622 SlotTracker *Machine, const Module *Context) {
1623 Out << "!DICompositeType(";
1624 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1625 Printer.printTag(N);
1626 Printer.printString("name", N->getName());
1627 Printer.printMetadata("scope", N->getRawScope());
1628 Printer.printMetadata("file", N->getRawFile());
1629 Printer.printInt("line", N->getLine());
1630 Printer.printMetadata("baseType", N->getRawBaseType());
1631 Printer.printInt("size", N->getSizeInBits());
1632 Printer.printInt("align", N->getAlignInBits());
1633 Printer.printInt("offset", N->getOffsetInBits());
1634 Printer.printDIFlags("flags", N->getFlags());
1635 Printer.printMetadata("elements", N->getRawElements());
1636 Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
1637 dwarf::LanguageString);
1638 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
1639 Printer.printMetadata("templateParams", N->getRawTemplateParams());
1640 Printer.printString("identifier", N->getIdentifier());
1644 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
1645 TypePrinting *TypePrinter,
1646 SlotTracker *Machine, const Module *Context) {
1647 Out << "!DISubroutineType(";
1648 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1649 Printer.printDIFlags("flags", N->getFlags());
1650 Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
1651 Printer.printMetadata("types", N->getRawTypeArray(),
1652 /* ShouldSkipNull */ false);
1656 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
1657 SlotTracker *, const Module *) {
1659 MDFieldPrinter Printer(Out);
1660 Printer.printString("filename", N->getFilename(),
1661 /* ShouldSkipEmpty */ false);
1662 Printer.printString("directory", N->getDirectory(),
1663 /* ShouldSkipEmpty */ false);
1664 Printer.printChecksumKind(N);
1665 Printer.printString("checksum", N->getChecksum(), /* ShouldSkipEmpty */ true);
1669 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
1670 TypePrinting *TypePrinter, SlotTracker *Machine,
1671 const Module *Context) {
1672 Out << "!DICompileUnit(";
1673 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1674 Printer.printDwarfEnum("language", N->getSourceLanguage(),
1675 dwarf::LanguageString, /* ShouldSkipZero */ false);
1676 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1677 Printer.printString("producer", N->getProducer());
1678 Printer.printBool("isOptimized", N->isOptimized());
1679 Printer.printString("flags", N->getFlags());
1680 Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
1681 /* ShouldSkipZero */ false);
1682 Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
1683 Printer.printEmissionKind("emissionKind", N->getEmissionKind());
1684 Printer.printMetadata("enums", N->getRawEnumTypes());
1685 Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
1686 Printer.printMetadata("globals", N->getRawGlobalVariables());
1687 Printer.printMetadata("imports", N->getRawImportedEntities());
1688 Printer.printMetadata("macros", N->getRawMacros());
1689 Printer.printInt("dwoId", N->getDWOId());
1690 Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
1694 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
1695 TypePrinting *TypePrinter, SlotTracker *Machine,
1696 const Module *Context) {
1697 Out << "!DISubprogram(";
1698 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1699 Printer.printString("name", N->getName());
1700 Printer.printString("linkageName", N->getLinkageName());
1701 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1702 Printer.printMetadata("file", N->getRawFile());
1703 Printer.printInt("line", N->getLine());
1704 Printer.printMetadata("type", N->getRawType());
1705 Printer.printBool("isLocal", N->isLocalToUnit());
1706 Printer.printBool("isDefinition", N->isDefinition());
1707 Printer.printInt("scopeLine", N->getScopeLine());
1708 Printer.printMetadata("containingType", N->getRawContainingType());
1709 Printer.printDwarfEnum("virtuality", N->getVirtuality(),
1710 dwarf::VirtualityString);
1711 if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
1712 N->getVirtualIndex() != 0)
1713 Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
1714 Printer.printInt("thisAdjustment", N->getThisAdjustment());
1715 Printer.printDIFlags("flags", N->getFlags());
1716 Printer.printBool("isOptimized", N->isOptimized());
1717 Printer.printMetadata("unit", N->getRawUnit());
1718 Printer.printMetadata("templateParams", N->getRawTemplateParams());
1719 Printer.printMetadata("declaration", N->getRawDeclaration());
1720 Printer.printMetadata("variables", N->getRawVariables());
1724 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
1725 TypePrinting *TypePrinter, SlotTracker *Machine,
1726 const Module *Context) {
1727 Out << "!DILexicalBlock(";
1728 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1729 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1730 Printer.printMetadata("file", N->getRawFile());
1731 Printer.printInt("line", N->getLine());
1732 Printer.printInt("column", N->getColumn());
1736 static void writeDILexicalBlockFile(raw_ostream &Out,
1737 const DILexicalBlockFile *N,
1738 TypePrinting *TypePrinter,
1739 SlotTracker *Machine,
1740 const Module *Context) {
1741 Out << "!DILexicalBlockFile(";
1742 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1743 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1744 Printer.printMetadata("file", N->getRawFile());
1745 Printer.printInt("discriminator", N->getDiscriminator(),
1746 /* ShouldSkipZero */ false);
1750 static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
1751 TypePrinting *TypePrinter, SlotTracker *Machine,
1752 const Module *Context) {
1753 Out << "!DINamespace(";
1754 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1755 Printer.printString("name", N->getName());
1756 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1757 Printer.printMetadata("file", N->getRawFile());
1758 Printer.printInt("line", N->getLine());
1759 Printer.printBool("exportSymbols", N->getExportSymbols(), false);
1763 static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
1764 TypePrinting *TypePrinter, SlotTracker *Machine,
1765 const Module *Context) {
1767 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1768 Printer.printMacinfoType(N);
1769 Printer.printInt("line", N->getLine());
1770 Printer.printString("name", N->getName());
1771 Printer.printString("value", N->getValue());
1775 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
1776 TypePrinting *TypePrinter, SlotTracker *Machine,
1777 const Module *Context) {
1778 Out << "!DIMacroFile(";
1779 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1780 Printer.printInt("line", N->getLine());
1781 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1782 Printer.printMetadata("nodes", N->getRawElements());
1786 static void writeDIModule(raw_ostream &Out, const DIModule *N,
1787 TypePrinting *TypePrinter, SlotTracker *Machine,
1788 const Module *Context) {
1789 Out << "!DIModule(";
1790 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1791 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1792 Printer.printString("name", N->getName());
1793 Printer.printString("configMacros", N->getConfigurationMacros());
1794 Printer.printString("includePath", N->getIncludePath());
1795 Printer.printString("isysroot", N->getISysRoot());
1800 static void writeDITemplateTypeParameter(raw_ostream &Out,
1801 const DITemplateTypeParameter *N,
1802 TypePrinting *TypePrinter,
1803 SlotTracker *Machine,
1804 const Module *Context) {
1805 Out << "!DITemplateTypeParameter(";
1806 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1807 Printer.printString("name", N->getName());
1808 Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
1812 static void writeDITemplateValueParameter(raw_ostream &Out,
1813 const DITemplateValueParameter *N,
1814 TypePrinting *TypePrinter,
1815 SlotTracker *Machine,
1816 const Module *Context) {
1817 Out << "!DITemplateValueParameter(";
1818 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1819 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
1820 Printer.printTag(N);
1821 Printer.printString("name", N->getName());
1822 Printer.printMetadata("type", N->getRawType());
1823 Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
1827 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
1828 TypePrinting *TypePrinter,
1829 SlotTracker *Machine, const Module *Context) {
1830 Out << "!DIGlobalVariable(";
1831 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1832 Printer.printString("name", N->getName());
1833 Printer.printString("linkageName", N->getLinkageName());
1834 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1835 Printer.printMetadata("file", N->getRawFile());
1836 Printer.printInt("line", N->getLine());
1837 Printer.printMetadata("type", N->getRawType());
1838 Printer.printBool("isLocal", N->isLocalToUnit());
1839 Printer.printBool("isDefinition", N->isDefinition());
1840 Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
1841 Printer.printInt("align", N->getAlignInBits());
1845 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
1846 TypePrinting *TypePrinter,
1847 SlotTracker *Machine, const Module *Context) {
1848 Out << "!DILocalVariable(";
1849 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1850 Printer.printString("name", N->getName());
1851 Printer.printInt("arg", N->getArg());
1852 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1853 Printer.printMetadata("file", N->getRawFile());
1854 Printer.printInt("line", N->getLine());
1855 Printer.printMetadata("type", N->getRawType());
1856 Printer.printDIFlags("flags", N->getFlags());
1857 Printer.printInt("align", N->getAlignInBits());
1861 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
1862 TypePrinting *TypePrinter, SlotTracker *Machine,
1863 const Module *Context) {
1864 Out << "!DIExpression(";
1867 for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
1868 auto OpStr = dwarf::OperationEncodingString(I->getOp());
1869 assert(!OpStr.empty() && "Expected valid opcode");
1872 for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
1873 Out << FS << I->getArg(A);
1876 for (const auto &I : N->getElements())
1882 static void writeDIGlobalVariableExpression(raw_ostream &Out,
1883 const DIGlobalVariableExpression *N,
1884 TypePrinting *TypePrinter,
1885 SlotTracker *Machine,
1886 const Module *Context) {
1887 Out << "!DIGlobalVariableExpression(";
1888 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1889 Printer.printMetadata("var", N->getVariable());
1890 Printer.printMetadata("expr", N->getExpression());
1894 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
1895 TypePrinting *TypePrinter, SlotTracker *Machine,
1896 const Module *Context) {
1897 Out << "!DIObjCProperty(";
1898 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1899 Printer.printString("name", N->getName());
1900 Printer.printMetadata("file", N->getRawFile());
1901 Printer.printInt("line", N->getLine());
1902 Printer.printString("setter", N->getSetterName());
1903 Printer.printString("getter", N->getGetterName());
1904 Printer.printInt("attributes", N->getAttributes());
1905 Printer.printMetadata("type", N->getRawType());
1909 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
1910 TypePrinting *TypePrinter,
1911 SlotTracker *Machine, const Module *Context) {
1912 Out << "!DIImportedEntity(";
1913 MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1914 Printer.printTag(N);
1915 Printer.printString("name", N->getName());
1916 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1917 Printer.printMetadata("entity", N->getRawEntity());
1918 Printer.printInt("line", N->getLine());
1923 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
1924 TypePrinting *TypePrinter,
1925 SlotTracker *Machine,
1926 const Module *Context) {
1927 if (Node->isDistinct())
1929 else if (Node->isTemporary())
1930 Out << "<temporary!> "; // Handle broken code.
1932 switch (Node->getMetadataID()) {
1934 llvm_unreachable("Expected uniquable MDNode");
1935 #define HANDLE_MDNODE_LEAF(CLASS) \
1936 case Metadata::CLASS##Kind: \
1937 write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
1939 #include "llvm/IR/Metadata.def"
1943 // Full implementation of printing a Value as an operand with support for
1944 // TypePrinting, etc.
1945 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1946 TypePrinting *TypePrinter,
1947 SlotTracker *Machine,
1948 const Module *Context) {
1950 PrintLLVMName(Out, V);
1954 const Constant *CV = dyn_cast<Constant>(V);
1955 if (CV && !isa<GlobalValue>(CV)) {
1956 assert(TypePrinter && "Constants require TypePrinting!");
1957 WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
1961 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
1963 if (IA->hasSideEffects())
1964 Out << "sideeffect ";
1965 if (IA->isAlignStack())
1966 Out << "alignstack ";
1967 // We don't emit the AD_ATT dialect as it
's the assumed default.
1968 if (IA->getDialect() == InlineAsm::AD_Intel)
1969 Out << "inteldialect ";
1971 PrintEscapedString(IA->getAsmString(), Out);
1978 if (
auto *MD = dyn_cast<MetadataAsValue>(V)) {
1988 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
1989 Slot = Machine->getGlobalSlot(GV);
1992 Slot = Machine->getLocalSlot(V);
1999 Slot = Machine->getLocalSlot(V);
2005 if (
const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2006 Slot = Machine->getGlobalSlot(GV);
2009 Slot = Machine->getLocalSlot(V);
2018 Out << Prefix << Slot;
2024 TypePrinting *TypePrinter,
2027 if (
const MDNode *N = dyn_cast<MDNode>(MD)) {
2028 std::unique_ptr<SlotTracker> MachineStorage;
2030 MachineStorage = make_unique<SlotTracker>(
Context);
2031 Machine = MachineStorage.get();
2037 Out <<
"<" << N <<
">";
2043 if (
const MDString *MDS = dyn_cast<MDString>(MD)) {
2050 auto *V = cast<ValueAsMetadata>(MD);
2051 assert(TypePrinter &&
"TypePrinter required for metadata values");
2052 assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2053 "Unexpected function-local metadata outside of value argument");
2055 TypePrinter->print(V->getValue()->
getType(), Out);
2061 class AssemblyWriter {
2064 std::unique_ptr<SlotTracker> SlotTrackerStorage;
2066 TypePrinting TypePrinter;
2070 bool ShouldPreserveUseListOrder;
2078 bool ShouldPreserveUseListOrder =
false);
2080 void printMDNodeBody(
const MDNode *MD);
2083 void printModule(
const Module *M);
2085 void writeOperand(
const Value *
Op,
bool PrintType);
2093 void writeAllMDNodes();
2094 void writeMDNode(
unsigned Slot,
const MDNode *Node);
2095 void writeAllAttributeGroups();
2097 void printTypeIdentities();
2100 void printComdat(
const Comdat *
C);
2101 void printFunction(
const Function *F);
2108 void printUseLists(
const Function *F);
2112 void printMetadataAttachments(
2118 void printInfoComment(
const Value &V);
2128 bool IsForDebug,
bool ShouldPreserveUseListOrder)
2129 : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
2130 IsForDebug(IsForDebug),
2131 ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2134 TypePrinter.incorporateTypes(*TheModule);
2135 for (
const GlobalObject &GO : TheModule->global_objects())
2140 void AssemblyWriter::writeOperand(
const Value *Operand,
bool PrintType) {
2142 Out <<
"<null operand!>";
2146 TypePrinter.print(Operand->
getType(), Out);
2154 if (Ordering == AtomicOrdering::NotAtomic)
2157 switch (SynchScope) {
2165 void AssemblyWriter::writeAtomicCmpXchg(
AtomicOrdering SuccessOrdering,
2168 assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2169 FailureOrdering != AtomicOrdering::NotAtomic);
2171 switch (SynchScope) {
2180 void AssemblyWriter::writeParamOperand(
const Value *Operand,
2183 Out <<
"<null operand!>";
2188 TypePrinter.print(Operand->
getType(), Out);
2203 bool FirstBundle =
true;
2209 FirstBundle =
false;
2217 bool FirstInput =
true;
2218 for (
const auto &Input : BU.
Inputs) {
2223 TypePrinter.print(Input->getType(), Out);
2234 void AssemblyWriter::printModule(
const Module *M) {
2235 Machine.initialize();
2237 if (ShouldPreserveUseListOrder)
2247 Out <<
"source_filename = \"";
2254 Out <<
"target datalayout = \"" << DL <<
"\"\n";
2265 std::tie(Front, Asm) = Asm.
split(
'\n');
2269 Out <<
"module asm \"";
2272 }
while (!Asm.
empty());
2275 printTypeIdentities();
2278 if (!Comdats.empty())
2280 for (
const Comdat *
C : Comdats) {
2282 if (
C != Comdats.back())
2289 printGlobal(&GV); Out <<
'\n';
2295 printIndirectSymbol(&GA);
2300 printIndirectSymbol(&GI);
2303 printUseLists(
nullptr);
2308 assert(UseListOrders.empty() &&
"All use-lists should have been consumed");
2311 if (!Machine.as_empty()) {
2313 writeAllAttributeGroups();
2317 if (!M->named_metadata_empty()) Out <<
'\n';
2319 for (
const NamedMDNode &Node : M->named_metadata())
2320 printNamedMDNode(&Node);
2323 if (!Machine.mdn_empty()) {
2332 Out <<
"<empty name> ";
2334 if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] ==
'-' ||
2335 Name[0] ==
'$' || Name[0] ==
'.' || Name[0] ==
'_')
2338 Out << '\\' << hexdigit(Name[0] >> 4) <<
hexdigit(Name[0] & 0x0F);
2339 for (
unsigned i = 1, e = Name.
size();
i != e; ++
i) {
2340 unsigned char C = Name[
i];
2341 if (isalnum(static_cast<unsigned char>(C)) || C ==
'-' || C ==
'$' ||
2342 C ==
'.' || C ==
'_')
2345 Out << '\\' << hexdigit(C >> 4) <<
hexdigit(C & 0x0F);
2350 void AssemblyWriter::printNamedMDNode(
const NamedMDNode *NMD) {
2357 int Slot = Machine.getMetadataSlot(NMD->
getOperand(
i));
2368 case GlobalValue::ExternalLinkage:
2370 case GlobalValue::PrivateLinkage:
2372 case GlobalValue::InternalLinkage:
2374 case GlobalValue::LinkOnceAnyLinkage:
2376 case GlobalValue::LinkOnceODRLinkage:
2377 return "linkonce_odr ";
2378 case GlobalValue::WeakAnyLinkage:
2380 case GlobalValue::WeakODRLinkage:
2382 case GlobalValue::CommonLinkage:
2384 case GlobalValue::AppendingLinkage:
2385 return "appending ";
2386 case GlobalValue::ExternalWeakLinkage:
2387 return "extern_weak ";
2388 case GlobalValue::AvailableExternallyLinkage:
2389 return "available_externally ";
2397 case GlobalValue::DefaultVisibility:
break;
2398 case GlobalValue::HiddenVisibility: Out <<
"hidden ";
break;
2399 case GlobalValue::ProtectedVisibility: Out <<
"protected ";
break;
2406 case GlobalValue::DefaultStorageClass:
break;
2407 case GlobalValue::DLLImportStorageClass: Out <<
"dllimport ";
break;
2408 case GlobalValue::DLLExportStorageClass: Out <<
"dllexport ";
break;
2415 case GlobalVariable::NotThreadLocal:
2417 case GlobalVariable::GeneralDynamicTLSModel:
2418 Out <<
"thread_local ";
2420 case GlobalVariable::LocalDynamicTLSModel:
2421 Out <<
"thread_local(localdynamic) ";
2423 case GlobalVariable::InitialExecTLSModel:
2424 Out <<
"thread_local(initialexec) ";
2426 case GlobalVariable::LocalExecTLSModel:
2427 Out <<
"thread_local(localexec) ";
2437 return "local_unnamed_addr";
2439 return "unnamed_addr";
2450 if (isa<GlobalVariable>(GO))
2464 Out <<
"; Materializable\n";
2483 Out << (GV->
isConstant() ?
"constant " :
"global ");
2492 Out <<
", section \"";
2502 printMetadataAttachments(MDs,
", ");
2504 printInfoComment(*GV);
2509 Out <<
"; Materializable\n";
2522 if (isa<GlobalAlias>(GIS))
2524 else if (isa<GlobalIFunc>(GIS))
2536 TypePrinter.print(GIS->
getType(), Out);
2537 Out <<
" <<NULL ALIASEE>>";
2539 writeOperand(IS, !isa<ConstantExpr>(IS));
2542 printInfoComment(*GIS);
2546 void AssemblyWriter::printComdat(
const Comdat *
C) {
2550 void AssemblyWriter::printTypeIdentities() {
2551 if (TypePrinter.NumberedTypes.empty() &&
2552 TypePrinter.NamedTypes.empty())
2559 std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
2561 TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
2563 assert(I->second < NumberedTypes.size() &&
"Didn't get a dense numbering?");
2564 NumberedTypes[I->second] = I->first;
2568 for (
unsigned i = 0, e = NumberedTypes.size();
i != e; ++
i) {
2569 Out <<
'%' <<
i <<
" = type ";
2573 TypePrinter.printStructBody(NumberedTypes[i], Out);
2577 for (
unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++
i) {
2583 TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
2590 void AssemblyWriter::printFunction(
const Function *F) {
2594 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
2597 Out <<
"; Materializable\n";
2602 std::string AttrStr;
2606 if (AS.
getSlotIndex(Idx) == AttributeSet::FunctionIndex)
2613 if (!AttrStr.empty()) AttrStr +=
' ';
2618 if (!AttrStr.empty())
2619 Out <<
"; Function Attrs: " << AttrStr <<
'\n';
2622 Machine.incorporateFunction(F);
2628 printMetadataAttachments(MDs,
" ");
2645 Out << Attrs.
getAsString(AttributeSet::ReturnIndex) <<
' ';
2671 printArgument(&Arg, Attrs, Idx++);
2685 Out <<
" #" << Machine.getAttributeGroupSlot(Attrs.
getFnAttributes());
2687 Out <<
" section \"";
2695 Out <<
" gc \"" << F->
getGC() <<
'"';
2701 Out <<
" prologue ";
2705 Out <<
" personality ";
2714 printMetadataAttachments(MDs,
" ");
2719 printBasicBlock(&BB);
2727 Machine.purgeFunction();
2733 void AssemblyWriter::printArgument(
const Argument *Arg,
2736 TypePrinter.print(Arg->
getType(), Out);
2751 void AssemblyWriter::printBasicBlock(
const BasicBlock *BB) {
2757 Out <<
"\n; <label>:";
2758 int Slot = Machine.getLocalSlot(BB);
2766 Out.PadToColumn(50);
2767 Out <<
"; Error: Block without parent!";
2770 Out.PadToColumn(50);
2775 Out <<
" No predecessors!";
2778 writeOperand(*PI,
false);
2779 for (++PI; PI != PE; ++PI) {
2781 writeOperand(*PI,
false);
2788 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
2792 printInstructionLine(I);
2795 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
2799 void AssemblyWriter::printInstructionLine(
const Instruction &I) {
2800 printInstruction(I);
2806 void AssemblyWriter::printGCRelocateComment(
const GCRelocateInst &Relocate) {
2817 void AssemblyWriter::printInfoComment(
const Value &V) {
2818 if (
const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
2819 printGCRelocateComment(*Relocate);
2821 if (AnnotationWriter)
2822 AnnotationWriter->printInfoComment(V, Out);
2826 void AssemblyWriter::printInstruction(
const Instruction &I) {
2827 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
2838 int SlotNum = Machine.getLocalSlot(&I);
2840 Out <<
"<badref> = ";
2842 Out <<
'%' << SlotNum <<
" = ";
2845 if (
const CallInst *CI = dyn_cast<CallInst>(&I)) {
2846 if (CI->isMustTailCall())
2848 else if (CI->isTailCall())
2850 else if (CI->isNoTailCall())
2858 if ((isa<LoadInst>(I) && cast<LoadInst>(I).
isAtomic()) ||
2859 (isa<StoreInst>(I) && cast<StoreInst>(I).
isAtomic()))
2862 if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).
isWeak())
2866 if ((isa<LoadInst>(I) && cast<LoadInst>(I).
isVolatile()) ||
2867 (isa<StoreInst>(I) && cast<StoreInst>(I).
isVolatile()) ||
2868 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).
isVolatile()) ||
2869 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).
isVolatile()))
2876 if (
const CmpInst *CI = dyn_cast<CmpInst>(&I))
2877 Out <<
' ' << CmpInst::getPredicateName(CI->getPredicate());
2880 if (
const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
2887 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
2890 writeOperand(BI.getCondition(),
true);
2892 writeOperand(BI.getSuccessor(0),
true);
2894 writeOperand(BI.getSuccessor(1),
true);
2896 }
else if (isa<SwitchInst>(I)) {
2900 writeOperand(
SI.getCondition(),
true);
2902 writeOperand(
SI.getDefaultDest(),
true);
2907 writeOperand(i.getCaseValue(),
true);
2909 writeOperand(i.getCaseSuccessor(),
true);
2912 }
else if (isa<IndirectBrInst>(I)) {
2915 writeOperand(Operand,
true);
2924 }
else if (
const PHINode *PN = dyn_cast<PHINode>(&I)) {
2926 TypePrinter.print(I.
getType(), Out);
2929 for (
unsigned op = 0, Eop = PN->getNumIncomingValues();
op < Eop; ++
op) {
2930 if (
op) Out <<
", ";
2932 writeOperand(PN->getIncomingValue(
op),
false); Out <<
", ";
2933 writeOperand(PN->getIncomingBlock(
op),
false); Out <<
" ]";
2938 for (
const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++
i)
2940 }
else if (
const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
2942 writeOperand(I.
getOperand(0),
true); Out <<
", ";
2944 for (
const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++
i)
2946 }
else if (
const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
2948 TypePrinter.print(I.
getType(), Out);
2949 if (LPI->isCleanup() || LPI->getNumClauses() != 0)
2952 if (LPI->isCleanup())
2955 for (
unsigned i = 0, e = LPI->getNumClauses(); i != e; ++
i) {
2956 if (i != 0 || LPI->isCleanup()) Out <<
"\n";
2957 if (LPI->isCatch(i))
2962 writeOperand(LPI->getClause(i),
true);
2964 }
else if (
const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
2966 writeOperand(CatchSwitch->getParentPad(),
false);
2969 for (
const BasicBlock *PadBB : CatchSwitch->handlers()) {
2972 writeOperand(PadBB,
true);
2976 if (
const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
2977 writeOperand(UnwindDest,
true);
2980 }
else if (
const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
2982 writeOperand(FPI->getParentPad(),
false);
2984 for (
unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
2988 writeOperand(FPI->getArgOperand(Op),
true);
2991 }
else if (isa<ReturnInst>(I) && !Operand) {
2993 }
else if (
const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
2995 writeOperand(CRI->getOperand(0),
false);
2998 writeOperand(CRI->getOperand(1),
true);
2999 }
else if (
const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3001 writeOperand(CRI->getOperand(0),
false);
3004 if (CRI->hasUnwindDest())
3005 writeOperand(CRI->getOperand(1),
true);
3008 }
else if (
const CallInst *CI = dyn_cast<CallInst>(&I)) {
3015 Operand = CI->getCalledValue();
3021 Out <<
' ' << PAL.
getAsString(AttributeSet::ReturnIndex);
3028 TypePrinter.print(FTy->
isVarArg() ? FTy : RetTy, Out);
3030 writeOperand(Operand,
false);
3032 for (
unsigned op = 0, Eop = CI->getNumArgOperands();
op < Eop; ++
op) {
3035 writeParamOperand(CI->getArgOperand(
op), PAL,
op + 1);
3040 if (CI->isMustTailCall() && CI->getParent() &&
3041 CI->getParent()->getParent() &&
3042 CI->getParent()->getParent()->isVarArg())
3049 writeOperandBundles(CI);
3051 }
else if (
const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3052 Operand = II->getCalledValue();
3064 Out <<
' ' << PAL.
getAsString(AttributeSet::ReturnIndex);
3071 TypePrinter.print(FTy->
isVarArg() ? FTy : RetTy, Out);
3073 writeOperand(Operand,
false);
3075 for (
unsigned op = 0, Eop = II->getNumArgOperands();
op < Eop; ++
op) {
3078 writeParamOperand(II->getArgOperand(
op), PAL,
op + 1);
3085 writeOperandBundles(II);
3088 writeOperand(II->getNormalDest(),
true);
3090 writeOperand(II->getUnwindDest(),
true);
3092 }
else if (
const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3094 if (AI->isUsedWithInAlloca())
3096 if (AI->isSwiftError())
3097 Out <<
"swifterror ";
3098 TypePrinter.print(AI->getAllocatedType(), Out);
3104 if (!AI->getArraySize() || AI->isArrayAllocation() ||
3105 !AI->getArraySize()->getType()->isIntegerTy(32)) {
3107 writeOperand(AI->getArraySize(),
true);
3109 if (AI->getAlignment()) {
3110 Out <<
", align " << AI->getAlignment();
3112 }
else if (isa<CastInst>(I)) {
3115 writeOperand(Operand,
true);
3118 TypePrinter.print(I.
getType(), Out);
3119 }
else if (isa<VAArgInst>(I)) {
3122 writeOperand(Operand,
true);
3125 TypePrinter.print(I.
getType(), Out);
3126 }
else if (Operand) {
3127 if (
const auto *
GEP = dyn_cast<GetElementPtrInst>(&I)) {
3129 TypePrinter.print(
GEP->getSourceElementType(), Out);
3131 }
else if (
const auto *LI = dyn_cast<LoadInst>(&I)) {
3133 TypePrinter.print(LI->getType(), Out);
3140 bool PrintAllTypes =
false;
3144 if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3145 || isa<ReturnInst>(I)) {
3146 PrintAllTypes =
true;
3152 if (Operand && Operand->
getType() != TheType) {
3153 PrintAllTypes =
true;
3159 if (!PrintAllTypes) {
3161 TypePrinter.print(TheType, Out);
3167 writeOperand(I.
getOperand(i), PrintAllTypes);
3172 if (
const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3174 writeAtomic(LI->getOrdering(), LI->getSynchScope());
3175 if (LI->getAlignment())
3176 Out <<
", align " << LI->getAlignment();
3177 }
else if (
const StoreInst *
SI = dyn_cast<StoreInst>(&I)) {
3179 writeAtomic(
SI->getOrdering(),
SI->getSynchScope());
3180 if (
SI->getAlignment())
3181 Out <<
", align " <<
SI->getAlignment();
3183 writeAtomicCmpXchg(CXI->getSuccessOrdering(), CXI->getFailureOrdering(),
3184 CXI->getSynchScope());
3185 }
else if (
const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
3186 writeAtomic(RMWI->getOrdering(), RMWI->getSynchScope());
3187 }
else if (
const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
3188 writeAtomic(FI->getOrdering(), FI->getSynchScope());
3194 printMetadataAttachments(InstMD,
", ");
3197 printInfoComment(I);
3200 void AssemblyWriter::printMetadataAttachments(
3206 if (MDNames.empty())
3207 MDs[0].second->getContext().getMDKindNames(MDNames);
3209 for (
const auto &I : MDs) {
3210 unsigned Kind = I.first;
3212 if (Kind < MDNames.size()) {
3216 Out <<
"!<unknown kind #" << Kind <<
">";
3222 void AssemblyWriter::writeMDNode(
unsigned Slot,
const MDNode *Node) {
3223 Out <<
'!' << Slot <<
" = ";
3224 printMDNodeBody(Node);
3228 void AssemblyWriter::writeAllMDNodes() {
3230 Nodes.
resize(Machine.mdn_size());
3233 Nodes[I->second] = cast<MDNode>(I->first);
3235 for (
unsigned i = 0, e = Nodes.
size(); i != e; ++
i) {
3236 writeMDNode(i, Nodes[i]);
3240 void AssemblyWriter::printMDNodeBody(
const MDNode *Node) {
3244 void AssemblyWriter::writeAllAttributeGroups() {
3245 std::vector<std::pair<AttributeSet, unsigned> > asVec;
3246 asVec.resize(Machine.as_size());
3250 asVec[I->second] = *I;
3252 for (
const auto &I : asVec)
3253 Out <<
"attributes #" << I.second <<
" = { "
3254 << I.first.getAsString(AttributeSet::FunctionIndex,
true) <<
" }\n";
3257 void AssemblyWriter::printUseListOrder(
const UseListOrder &Order) {
3262 Out <<
"uselistorder";
3264 IsInFunction ?
nullptr : dyn_cast<BasicBlock>(Order.
V)) {
3266 writeOperand(BB->getParent(),
false);
3268 writeOperand(BB,
false);
3271 writeOperand(Order.
V,
true);
3277 for (
unsigned I = 1, E = Order.
Shuffle.size(); I !=
E; ++
I)
3278 Out <<
", " << Order.
Shuffle[I];
3282 void AssemblyWriter::printUseLists(
const Function *F) {
3284 [&]() {
return !UseListOrders.empty() && UseListOrders.back().F ==
F; };
3289 Out <<
"\n; uselistorder directives\n";
3291 printUseListOrder(UseListOrders.back());
3292 UseListOrders.pop_back();
3301 bool ShouldPreserveUseListOrder,
3302 bool IsForDebug)
const {
3305 AssemblyWriter W(OS, SlotTable, this->
getParent(), AAW,
3307 ShouldPreserveUseListOrder);
3308 W.printFunction(
this);
3312 bool ShouldPreserveUseListOrder,
bool IsForDebug)
const {
3315 AssemblyWriter W(OS, SlotTable,
this, AAW, IsForDebug,
3316 ShouldPreserveUseListOrder);
3317 W.printModule(
this);
3323 AssemblyWriter W(OS, SlotTable,
getParent(),
nullptr, IsForDebug);
3324 W.printNamedMDNode(
this);
3328 bool IsForDebug)
const {
3335 SlotTable = &*LocalST;
3339 AssemblyWriter W(OS, *SlotTable,
getParent(),
nullptr, IsForDebug);
3340 W.printNamedMDNode(
this);
3345 ROS <<
" = comdat ";
3352 ROS <<
"exactmatch";
3358 ROS <<
"noduplicates";
3370 TP.print(const_cast<Type*>(
this), OS);
3376 if (
StructType *STy = dyn_cast<StructType>(const_cast<Type*>(
this)))
3379 TP.printStructBody(STy, OS);
3384 if (
const auto *CI = dyn_cast<CallInst>(&I))
3385 if (
Function *F = CI->getCalledFunction())
3388 if (
auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
3389 if (isa<MDNode>(V->getMetadata()))
3395 bool ShouldInitializeAllMetadata =
false;
3396 if (
auto *I = dyn_cast<Instruction>(
this))
3398 else if (isa<Function>(
this) || isa<MetadataAsValue>(
this))
3399 ShouldInitializeAllMetadata =
true;
3402 print(ROS, MST, IsForDebug);
3406 bool IsForDebug)
const {
3408 SlotTracker EmptySlotTable(static_cast<const Module *>(
nullptr));
3411 auto incorporateFunction = [&](
const Function *
F) {
3416 if (
const Instruction *I = dyn_cast<Instruction>(
this)) {
3419 W.printInstruction(*I);
3420 }
else if (
const BasicBlock *BB = dyn_cast<BasicBlock>(
this)) {
3421 incorporateFunction(BB->getParent());
3422 AssemblyWriter W(OS, SlotTable,
getModuleFromVal(BB),
nullptr, IsForDebug);
3423 W.printBasicBlock(BB);
3424 }
else if (
const GlobalValue *GV = dyn_cast<GlobalValue>(
this)) {
3425 AssemblyWriter W(OS, SlotTable, GV->
getParent(),
nullptr, IsForDebug);
3428 else if (
const Function *F = dyn_cast<Function>(GV))
3431 W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
3432 }
else if (
const MetadataAsValue *V = dyn_cast<MetadataAsValue>(
this)) {
3434 }
else if (
const Constant *C = dyn_cast<Constant>(
this)) {
3435 TypePrinting TypePrinter;
3436 TypePrinter.print(C->getType(), OS);
3439 }
else if (isa<InlineAsm>(
this) || isa<Argument>(
this)) {
3451 if (V.
hasName() || isa<GlobalValue>(V) ||
3452 (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
3461 TypePrinting TypePrinter;
3463 TypePrinter.incorporateTypes(*M);
3465 TypePrinter.print(V.
getType(), O);
3483 M, isa<MetadataAsValue>(
this));
3499 bool OnlyAsOperand) {
3502 TypePrinting TypePrinter;
3504 TypePrinter.incorporateTypes(*M);
3510 if (OnlyAsOperand || !N)
3534 const Module *M,
bool )
const {
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
static SlotTracker * createSlotTracker(const Value *V)
StringRef getName() const
void push_back(const T &Elt)
LinkageTypes getLinkage() const
static void WriteOptimizationInfo(raw_ostream &Out, const User *U)
This class is the base class for the comparison instructions.
SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
iterator_range< use_iterator > uses()
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
VisibilityTypes getVisibility() const
*p = old <signed v ? old : v
unsigned getNumOperandBundles() const
LLVM Argument representation.
void purgeFunction()
After calling incorporateFunction, use this method to remove the most recently incorporated function ...
Constant * getPrologueData() const
Get the prologue data associated with this function.
uint64_t getZExtValue() const
Get zero extended value.
static bool printWithoutType(const Value &V, raw_ostream &O, SlotTracker *Machine, const Module *M)
Print without a type, skipping the TypePrinting object.
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
std::string getAsString(unsigned Index, bool InAttrGrp=false) const
Return the attributes at the index as a string.
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
A Module instance is used to store all the information related to an LLVM module. ...
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
void PrintEscapedString(StringRef Name, raw_ostream &Out)
PrintEscapedString - Print each character of the specified string, escaping it if it is not printable...
2: 32-bit floating point type
An instruction for ordering other memory operations.
static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
unsigned getNumOperands() const
MSP430_INTR - Calling convention used for MSP430 interrupt routines.
unsigned getNumOperands() const
Return number of MDNode operands.
static void writeAtomicRMWOperation(raw_ostream &Out, AtomicRMWInst::BinOp Op)
Type::subtype_iterator param_iterator
UnnamedAddr getUnnamedAddr() const
Type * getValueType() const
Calling convention used for Mesa vertex shaders.
This class represents a function call, abstracting a target machine's calling convention.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Calling convention used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cac...
*p = old <unsigned v ? old : v
static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
*p = old >unsigned v ? old : v
void initialize()
This function does the actual initialization.
iterator begin(unsigned Slot) const
The data referenced by the COMDAT must be the same size.
A raw_ostream that writes to an SmallVector or SmallString.
Type * getReturnType() const
Returns the type of the ret val.
DenseMap< AttributeSet, unsigned >::iterator as_iterator
AttributeSet map iterators.
const Function * getParent() const
Return the enclosing method, or null if none.
bool hasPrologueData() const
Check whether this function has prologue data.
int getGlobalSlot(const GlobalValue *V)
getGlobalSlot - Get the slot number of a global value.
4: 80-bit floating point type (X87)
unsigned getAddressSpace() const
Return the address space of the Pointer type.
An instruction for reading from memory.
Manage lifetime of a slot tracker for printing IR.
1: 16-bit floating point type
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
Get all metadata attached to this Instruction.
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Type * getElementType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
*p = old >signed v ? old : v
int getMetadataSlot(const MDNode *N)
getMetadataSlot - Get the slot number of a MDNode.
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
static void PrintCallingConv(unsigned cc, raw_ostream &Out)
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
bool isMaterializable() const
StringRef getName() const
Return a constant reference to the value's name.
SlotTracker * getMachine()
Lazily creates a slot tracker.
static void predictValueUseListOrder(const Value *V, const Function *F, OrderMap &OM, UseListOrderStack &Stack)
static const char * getLinkagePrintName(GlobalValue::LinkageTypes LT)
The address of a basic block.
StringRef getTagName() const
Return the tag of this operand bundle as a string.
Value * getDerivedPtr() const
std::vector< unsigned > Shuffle
static OrderMap orderModule(const Module *M)
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
std::string getAsString(bool InAttrGrp=false) const
The Attribute is converted to a string of equivalent mnemonic.
static const fltSemantics & x87DoubleExtended()
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand)
X86_INTR - x86 hardware interrupt context.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Class to represent struct types.
A Use represents the edge between a Value definition and its users.
param_iterator param_end() const
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
PTX_Kernel - Call to a PTX kernel.
bool isLiteral() const
Return true if this type is uniqued by structural equivalence, false if it is a struct definition...
Constant * getPersonalityFn() const
Get the personality function associated with this function.
std::vector< UseListOrder > UseListOrderStack
APInt bitcastToAPInt() const
The linker may choose any COMDAT.
Register calling convention used for parameters transfer optimization.
Type * getVectorElementType() const
static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
StringRef getName() const
X86_ThisCall - Similar to X86_StdCall.
LLVM_NODISCARD bool empty() const
AtomicOrdering
Atomic ordering for LLVM's memory model.
void print(raw_ostream &OS, bool IsForDebug=false) const
Class to represent function types.
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
BinOp
This enumeration lists the possible modifications atomicrmw can make.
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.
unsigned getAlignment() const
Class to represent array types.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Value * getBasePtr() const
bool isMaterializable() const
If this function's Module is being lazily streamed in functions from disk or some other source...
StringRef getSection() const
Get the custom section of this global if it has one.
X86_FastCall - 'fast' analog of X86_StdCall.
TypeID getTypeID() const
Return the type id for the type.
const Function * getFunction() const
Return the function this instruction belongs to.
An instruction for storing to memory.
COFF::MachineTypes Machine
static void PrintVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)
Structure to hold a use-list order.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
const char * getOpcodeName() const
Type * getElementType() const
int getLocalSlot(const Value *V)
Return the slot number of the specified value in it's type plane.
Class to represent pointers.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
static const fltSemantics & IEEEsingle()
bool hasOperandBundles() const
bool global_empty() const
11: Arbitrary bit width integers
bool hasSection() const
Check if this global has a custom object file section.
This class provides computation of slot numbers for LLVM Assembly writing.
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
Type * getParamType(unsigned i) const
Parameter type accessors.
bool isExternallyInitialized() const
No other Module may specify this COMDAT.
The landingpad instruction holds all of the information necessary to generate correct exception handl...
void dump() const
Dump the module to stderr (for debugging).
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
static void predictValueUseListOrderImpl(const Value *V, const Function *F, unsigned ID, const OrderMap &OM, UseListOrderStack &Stack)
LLVM Basic Block Representation.
The instances of the Type class are immutable: once they are created, they are never changed...
Conditional or Unconditional Branch instruction.
Calling convention for AMDGPU code object kernels.
const Comdat * getComdat() const
This is an important base class in LLVM.
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
This file contains the declarations for the subclasses of Constant, which represent the different fla...
param_iterator param_begin() const
ConstantFP - Floating Point Values [float, double].
static const fltSemantics & IEEEhalf()
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
bool hasPersonalityFn() const
Check whether this function has a personality function.
iterator_range< named_metadata_iterator > named_metadata()
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed...
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
APInt getLoBits(unsigned numBits) const
Compute an APInt containing numBits lowbits from this APInt.
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul.
MDNode * getOperand(unsigned i) const
uint64_t getNumElements() const
for(unsigned i=0, e=MI->getNumOperands();i!=e;++i)
DLLStorageClassTypes
Storage classes of global values for PE targets.
6: 128-bit floating point type (two 64-bits, PowerPC)
Value * getOperand(unsigned i) const
static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)
Interval::pred_iterator pred_end(Interval *I)
SelectionKind getSelectionKind() const
Used for AVR interrupt routines.
static const Module * getModuleFromVal(const Value *V)
The data referenced by the COMDAT must be the same.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
void incorporateFunction(const Function &F)
Incorporate the given function.
static const fltSemantics & IEEEquad()
static bool isAtomic(Instruction *I)
static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)
Calling convention used for Mesa pixel shaders.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
OperandBundleUse getOperandBundleAt(unsigned Index) const
void dump() const
Support for debugging, callable in GDB: V->dump()
const std::string & getModuleInlineAsm() const
Get any module-scope inline assembly blocks.
static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix)
Turn the specified name into an 'LLVM name', which is either prefixed with % (if the string only cont...
reverse_iterator rbegin()
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
bool hasExternalLinkage() const
const MDOperand & getOperand(unsigned I) const
Iterator for intrusive lists based on ilist_node.
This is the shared class of boolean and integer constants.
APInt getHiBits(unsigned numBits) const
Compute an APInt containing numBits highbits from this APInt.
Calling convention used for Mesa geometry shaders.
PTX_Device - Call to a PTX device function.
16: SIMD 'packed' format, or other vector type
static const char * Separator
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Utility class for floating point operations which can have information about relaxed accuracy require...
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, TypePrinting &TypePrinter, SlotTracker *Machine, const Module *Context)
iterator end(unsigned Slot) const
HHVM calling convention for invoking C/C++ helpers.
void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name)
Print out a name of an LLVM value without any prefixes.
virtual ~AssemblyAnnotationWriter()
The linker will choose the largest COMDAT.
static bool isReferencingMDNode(const Instruction &I)
const BasicBlock & getEntryBlock() const
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
AttributeSet getAttributes() const
Return the attribute list for this Function.
Class to represent vector types.
bool hasInitializer() const
Definitions have initializers, declarations don't.
ConstantArray - Constant Array Declarations.
Class for arbitrary precision integers.
static const char * toIRString(AtomicOrdering ao)
String used by LLVM IR to represent atomic ordering.
static bool isWeak(const MCSymbolELF &Sym)
LinkageTypes
An enumeration for the kinds of linkage for global values.
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
StringRef getName() const
Return the name for this struct type if it has an identity.
A lightweight accessor for an operand bundle meant to be passed around by value.
iterator_range< user_iterator > users()
unsigned getVectorNumElements() const
SPIR_KERNEL - Calling convention for SPIR kernel functions.
The C convention as implemented on Windows/x86-64.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
static const fltSemantics & IEEEdouble()
static char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16)...
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the module to an output stream with an optional AssemblyAnnotationWriter.
ThreadLocalMode getThreadLocalMode() const
PointerType * getType() const
Global values are always pointers.
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
unsigned getSlotIndex(unsigned Slot) const
Return the index for the given slot.
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
static void orderValue(const Value *V, OrderMap &OM)
ImmutableCallSite - establish a view to a call site for examination.
FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width, bool Upper=false)
format_hex_no_prefix - Output N as a fixed width hexadecimal.
const std::string & getGC() const
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
FunctionType * getFunctionType() const
Returns the FunctionType for me.
static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)
static const fltSemantics & PPCDoubleDouble()
iterator find(const KeyT &Val)
bool hasPrefixData() const
Check whether this function has prefix data.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
bool isStringAttribute() const
Return true if the attribute is a string (target-dependent) attribute.
iterator_range< ifunc_iterator > ifuncs()
const std::string & getSourceFileName() const
Get the module's original source file name.
Constant * getPrefixData() const
Get the prefix data associated with this function.
const Module * getModule() const
Calling convention used for Mesa compute shaders.
const Constant * getIndirectSymbol() const
This file defines passes to print out IR in various granularities.
3: 64-bit floating point type
Type * getReturnType() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Represents calls to the gc.relocate intrinsic.
Module * getParent()
Get the module that this global value is contained inside of...
LLVM Value Representation.
A vector that has set insertion semantics.
DLLStorageClassTypes getDLLStorageClass() const
unsigned getNumOperands() const
This class implements an extremely fast bulk output stream that can only output to a stream...
void print(raw_ostream &ROS, bool IsForDebug=false) const
Calling convention used for AVR signal routines.
iterator_range< global_iterator > globals()
StringRef - Represent a constant reference to a string, i.e.
const std::string & getDataLayoutStr() const
Get the data layout string for the module's target platform.
static bool isVolatile(Instruction *Inst)
9: MMX vectors (64 bits, X86 specific)
void emplace(ArgTypes &&...Args)
Create a new object by constructing it in place with the given arguments.
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
ARM_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Fast - This calling convention attempts to make calls as fast as possible (e.g.
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
static UseListOrderStack predictUseListOrder(const Module *M)
const BasicBlock * getParent() const
int getAttributeGroupSlot(AttributeSet AS)
iterator_range< arg_iterator > args()
Module * getParent()
Get the module that holds this named metadata collection.
bool isVoidTy() const
Return true if this is 'void'.
an instruction to allocate memory on the stack
This instruction inserts a struct field of array element value into an aggregate value.
5: 128-bit floating point type (112-bit mantissa)
iterator_range< alias_iterator > aliases()
AttributeSet getFnAttributes() const
The function attributes are returned.