1 //===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This library implements the functionality defined in llvm/IR/Writer.h
12 // Note that these routines must be extremely tolerant of various errors in the
13 // LLVM code, because it can be used for debugging transformations.
15 //===----------------------------------------------------------------------===//
17 #include "AsmWriter.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SmallString.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/IR/AssemblyAnnotationWriter.h"
23 #include "llvm/IR/CFG.h"
24 #include "llvm/IR/CallingConv.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DebugInfo.h"
27 #include "llvm/IR/DerivedTypes.h"
28 #include "llvm/IR/IRPrintingPasses.h"
29 #include "llvm/IR/InlineAsm.h"
30 #include "llvm/IR/IntrinsicInst.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/Operator.h"
34 #include "llvm/IR/TypeFinder.h"
35 #include "llvm/IR/ValueSymbolTable.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/Dwarf.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/FormattedStream.h"
40 #include "llvm/Support/MathExtras.h"
45 // Make virtual table appear in this compilation unit.
46 AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
48 //===----------------------------------------------------------------------===//
50 //===----------------------------------------------------------------------===//
54 DenseMap
<const Value
*, std::pair
<unsigned, bool>> IDs
;
56 unsigned size() const { return IDs
.size(); }
57 std::pair
<unsigned, bool> &operator[](const Value
*V
) { return IDs
[V
]; }
58 std::pair
<unsigned, bool> lookup(const Value
*V
) const {
61 void index(const Value
*V
) {
62 // Explicitly sequence get-size and insert-value operations to avoid UB.
63 unsigned ID
= IDs
.size() + 1;
69 static void orderValue(const Value
*V
, OrderMap
&OM
) {
70 if (OM
.lookup(V
).first
)
73 if (const Constant
*C
= dyn_cast
<Constant
>(V
))
74 if (C
->getNumOperands() && !isa
<GlobalValue
>(C
))
75 for (const Value
*Op
: C
->operands())
76 if (!isa
<BasicBlock
>(Op
) && !isa
<GlobalValue
>(Op
))
79 // Note: we cannot cache this lookup above, since inserting into the map
80 // changes the map's size, and thus affects the other IDs.
84 static OrderMap
orderModule(const Module
*M
) {
85 // This needs to match the order used by ValueEnumerator::ValueEnumerator()
86 // and ValueEnumerator::incorporateFunction().
89 for (const GlobalVariable
&G
: M
->globals()) {
90 if (G
.hasInitializer())
91 if (!isa
<GlobalValue
>(G
.getInitializer()))
92 orderValue(G
.getInitializer(), OM
);
95 for (const GlobalAlias
&A
: M
->aliases()) {
96 if (!isa
<GlobalValue
>(A
.getAliasee()))
97 orderValue(A
.getAliasee(), OM
);
100 for (const Function
&F
: *M
) {
101 if (F
.hasPrefixData())
102 if (!isa
<GlobalValue
>(F
.getPrefixData()))
103 orderValue(F
.getPrefixData(), OM
);
105 if (F
.hasPrologueData())
106 if (!isa
<GlobalValue
>(F
.getPrologueData()))
107 orderValue(F
.getPrologueData(), OM
);
111 if (F
.isDeclaration())
114 for (const Argument
&A
: F
.args())
116 for (const BasicBlock
&BB
: F
) {
118 for (const Instruction
&I
: BB
) {
119 for (const Value
*Op
: I
.operands())
120 if ((isa
<Constant
>(*Op
) && !isa
<GlobalValue
>(*Op
)) ||
130 static void predictValueUseListOrderImpl(const Value
*V
, const Function
*F
,
131 unsigned ID
, const OrderMap
&OM
,
132 UseListOrderStack
&Stack
) {
133 // Predict use-list order for this one.
134 typedef std::pair
<const Use
*, unsigned> Entry
;
135 SmallVector
<Entry
, 64> List
;
136 for (const Use
&U
: V
->uses())
137 // Check if this user will be serialized.
138 if (OM
.lookup(U
.getUser()).first
)
139 List
.push_back(std::make_pair(&U
, List
.size()));
142 // We may have lost some users.
146 !isa
<GlobalVariable
>(V
) && !isa
<Function
>(V
) && !isa
<BasicBlock
>(V
);
147 if (auto *BA
= dyn_cast
<BlockAddress
>(V
))
148 ID
= OM
.lookup(BA
->getBasicBlock()).first
;
149 std::sort(List
.begin(), List
.end(), [&](const Entry
&L
, const Entry
&R
) {
150 const Use
*LU
= L
.first
;
151 const Use
*RU
= R
.first
;
155 auto LID
= OM
.lookup(LU
->getUser()).first
;
156 auto RID
= OM
.lookup(RU
->getUser()).first
;
158 // If ID is 4, then expect: 7 6 5 1 2 3.
172 // LID and RID are equal, so we have different operands of the same user.
173 // Assume operands are added in order for all instructions.
176 return LU
->getOperandNo() < RU
->getOperandNo();
177 return LU
->getOperandNo() > RU
->getOperandNo();
181 List
.begin(), List
.end(),
182 [](const Entry
&L
, const Entry
&R
) { return L
.second
< R
.second
; }))
183 // Order is already correct.
186 // Store the shuffle.
187 Stack
.emplace_back(V
, F
, List
.size());
188 assert(List
.size() == Stack
.back().Shuffle
.size() && "Wrong size");
189 for (size_t I
= 0, E
= List
.size(); I
!= E
; ++I
)
190 Stack
.back().Shuffle
[I
] = List
[I
].second
;
193 static void predictValueUseListOrder(const Value
*V
, const Function
*F
,
194 OrderMap
&OM
, UseListOrderStack
&Stack
) {
195 auto &IDPair
= OM
[V
];
196 assert(IDPair
.first
&& "Unmapped value");
198 // Already predicted.
201 // Do the actual prediction.
202 IDPair
.second
= true;
203 if (!V
->use_empty() && std::next(V
->use_begin()) != V
->use_end())
204 predictValueUseListOrderImpl(V
, F
, IDPair
.first
, OM
, Stack
);
206 // Recursive descent into constants.
207 if (const Constant
*C
= dyn_cast
<Constant
>(V
))
208 if (C
->getNumOperands()) // Visit GlobalValues.
209 for (const Value
*Op
: C
->operands())
210 if (isa
<Constant
>(Op
)) // Visit GlobalValues.
211 predictValueUseListOrder(Op
, F
, OM
, Stack
);
214 static UseListOrderStack
predictUseListOrder(const Module
*M
) {
215 OrderMap OM
= orderModule(M
);
217 // Use-list orders need to be serialized after all the users have been added
218 // to a value, or else the shuffles will be incomplete. Store them per
219 // function in a stack.
221 // Aside from function order, the order of values doesn't matter much here.
222 UseListOrderStack Stack
;
224 // We want to visit the functions backward now so we can list function-local
225 // constants in the last Function they're used in. Module-level constants
226 // have already been visited above.
227 for (auto I
= M
->rbegin(), E
= M
->rend(); I
!= E
; ++I
) {
228 const Function
&F
= *I
;
229 if (F
.isDeclaration())
231 for (const BasicBlock
&BB
: F
)
232 predictValueUseListOrder(&BB
, &F
, OM
, Stack
);
233 for (const Argument
&A
: F
.args())
234 predictValueUseListOrder(&A
, &F
, OM
, Stack
);
235 for (const BasicBlock
&BB
: F
)
236 for (const Instruction
&I
: BB
)
237 for (const Value
*Op
: I
.operands())
238 if (isa
<Constant
>(*Op
) || isa
<InlineAsm
>(*Op
)) // Visit GlobalValues.
239 predictValueUseListOrder(Op
, &F
, OM
, Stack
);
240 for (const BasicBlock
&BB
: F
)
241 for (const Instruction
&I
: BB
)
242 predictValueUseListOrder(&I
, &F
, OM
, Stack
);
245 // Visit globals last.
246 for (const GlobalVariable
&G
: M
->globals())
247 predictValueUseListOrder(&G
, nullptr, OM
, Stack
);
248 for (const Function
&F
: *M
)
249 predictValueUseListOrder(&F
, nullptr, OM
, Stack
);
250 for (const GlobalAlias
&A
: M
->aliases())
251 predictValueUseListOrder(&A
, nullptr, OM
, Stack
);
252 for (const GlobalVariable
&G
: M
->globals())
253 if (G
.hasInitializer())
254 predictValueUseListOrder(G
.getInitializer(), nullptr, OM
, Stack
);
255 for (const GlobalAlias
&A
: M
->aliases())
256 predictValueUseListOrder(A
.getAliasee(), nullptr, OM
, Stack
);
257 for (const Function
&F
: *M
)
258 if (F
.hasPrefixData())
259 predictValueUseListOrder(F
.getPrefixData(), nullptr, OM
, Stack
);
264 static const Module
*getModuleFromVal(const Value
*V
) {
265 if (const Argument
*MA
= dyn_cast
<Argument
>(V
))
266 return MA
->getParent() ? MA
->getParent()->getParent() : nullptr;
268 if (const BasicBlock
*BB
= dyn_cast
<BasicBlock
>(V
))
269 return BB
->getParent() ? BB
->getParent()->getParent() : nullptr;
271 if (const Instruction
*I
= dyn_cast
<Instruction
>(V
)) {
272 const Function
*M
= I
->getParent() ? I
->getParent()->getParent() : nullptr;
273 return M
? M
->getParent() : nullptr;
276 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(V
))
277 return GV
->getParent();
281 static void PrintCallingConv(unsigned cc
, raw_ostream
&Out
) {
283 default: Out
<< "cc" << cc
; break;
284 case CallingConv::Fast
: Out
<< "fastcc"; break;
285 case CallingConv::Cold
: Out
<< "coldcc"; break;
286 case CallingConv::WebKit_JS
: Out
<< "webkit_jscc"; break;
287 case CallingConv::AnyReg
: Out
<< "anyregcc"; break;
288 case CallingConv::PreserveMost
: Out
<< "preserve_mostcc"; break;
289 case CallingConv::PreserveAll
: Out
<< "preserve_allcc"; break;
290 case CallingConv::GHC
: Out
<< "ghccc"; break;
291 case CallingConv::X86_StdCall
: Out
<< "x86_stdcallcc"; break;
292 case CallingConv::X86_FastCall
: Out
<< "x86_fastcallcc"; break;
293 case CallingConv::X86_ThisCall
: Out
<< "x86_thiscallcc"; break;
294 case CallingConv::X86_VectorCall
:Out
<< "x86_vectorcallcc"; break;
295 case CallingConv::Intel_OCL_BI
: Out
<< "intel_ocl_bicc"; break;
296 case CallingConv::ARM_APCS
: Out
<< "arm_apcscc"; break;
297 case CallingConv::ARM_AAPCS
: Out
<< "arm_aapcscc"; break;
298 case CallingConv::ARM_AAPCS_VFP
: Out
<< "arm_aapcs_vfpcc"; break;
299 case CallingConv::MSP430_INTR
: Out
<< "msp430_intrcc"; break;
300 case CallingConv::PTX_Kernel
: Out
<< "ptx_kernel"; break;
301 case CallingConv::PTX_Device
: Out
<< "ptx_device"; break;
302 case CallingConv::X86_64_SysV
: Out
<< "x86_64_sysvcc"; break;
303 case CallingConv::X86_64_Win64
: Out
<< "x86_64_win64cc"; break;
304 case CallingConv::SPIR_FUNC
: Out
<< "spir_func"; break;
305 case CallingConv::SPIR_KERNEL
: Out
<< "spir_kernel"; break;
309 // PrintEscapedString - Print each character of the specified string, escaping
310 // it if it is not printable or if it is an escape char.
311 static void PrintEscapedString(StringRef Name
, raw_ostream
&Out
) {
312 for (unsigned i
= 0, e
= Name
.size(); i
!= e
; ++i
) {
313 unsigned char C
= Name
[i
];
314 if (isprint(C
) && C
!= '\\' && C
!= '"')
317 Out
<< '\\' << hexdigit(C
>> 4) << hexdigit(C
& 0x0F);
329 /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
330 /// prefixed with % (if the string only contains simple characters) or is
331 /// surrounded with ""'s (if it has special chars in it). Print it out.
332 static void PrintLLVMName(raw_ostream
&OS
, StringRef Name
, PrefixType Prefix
) {
333 assert(!Name
.empty() && "Cannot get empty name!");
335 case NoPrefix
: break;
336 case GlobalPrefix
: OS
<< '@'; break;
337 case ComdatPrefix
: OS
<< '$'; break;
338 case LabelPrefix
: break;
339 case LocalPrefix
: OS
<< '%'; break;
342 // Scan the name to see if it needs quotes first.
343 bool NeedsQuotes
= isdigit(static_cast<unsigned char>(Name
[0]));
345 for (unsigned i
= 0, e
= Name
.size(); i
!= e
; ++i
) {
346 // By making this unsigned, the value passed in to isalnum will always be
347 // in the range 0-255. This is important when building with MSVC because
348 // its implementation will assert. This situation can arise when dealing
349 // with UTF-8 multibyte characters.
350 unsigned char C
= Name
[i
];
351 if (!isalnum(static_cast<unsigned char>(C
)) && C
!= '-' && C
!= '.' &&
359 // If we didn't need any quotes, just write out the name in one blast.
365 // Okay, we need quotes. Output the quotes and escape any scary characters as
368 PrintEscapedString(Name
, OS
);
372 /// PrintLLVMName - Turn the specified name into an 'LLVM name', which is either
373 /// prefixed with % (if the string only contains simple characters) or is
374 /// surrounded with ""'s (if it has special chars in it). Print it out.
375 static void PrintLLVMName(raw_ostream
&OS
, const Value
*V
) {
376 PrintLLVMName(OS
, V
->getName(),
377 isa
<GlobalValue
>(V
) ? GlobalPrefix
: LocalPrefix
);
383 void TypePrinting::incorporateTypes(const Module
&M
) {
384 NamedTypes
.run(M
, false);
386 // The list of struct types we got back includes all the struct types, split
387 // the unnamed ones out to a numbering and remove the anonymous structs.
388 unsigned NextNumber
= 0;
390 std::vector
<StructType
*>::iterator NextToUse
= NamedTypes
.begin(), I
, E
;
391 for (I
= NamedTypes
.begin(), E
= NamedTypes
.end(); I
!= E
; ++I
) {
392 StructType
*STy
= *I
;
394 // Ignore anonymous types.
395 if (STy
->isLiteral())
398 if (STy
->getName().empty())
399 NumberedTypes
[STy
] = NextNumber
++;
404 NamedTypes
.erase(NextToUse
, NamedTypes
.end());
408 /// CalcTypeName - Write the specified type to the specified raw_ostream, making
409 /// use of type names or up references to shorten the type name where possible.
410 void TypePrinting::print(Type
*Ty
, raw_ostream
&OS
) {
411 switch (Ty
->getTypeID()) {
412 case Type::VoidTyID
: OS
<< "void"; return;
413 case Type::HalfTyID
: OS
<< "half"; return;
414 case Type::FloatTyID
: OS
<< "float"; return;
415 case Type::DoubleTyID
: OS
<< "double"; return;
416 case Type::X86_FP80TyID
: OS
<< "x86_fp80"; return;
417 case Type::FP128TyID
: OS
<< "fp128"; return;
418 case Type::PPC_FP128TyID
: OS
<< "ppc_fp128"; return;
419 case Type::LabelTyID
: OS
<< "label"; return;
420 case Type::MetadataTyID
: OS
<< "metadata"; return;
421 case Type::X86_MMXTyID
: OS
<< "x86_mmx"; return;
422 case Type::IntegerTyID
:
423 OS
<< 'i' << cast
<IntegerType
>(Ty
)->getBitWidth();
426 case Type::FunctionTyID
: {
427 FunctionType
*FTy
= cast
<FunctionType
>(Ty
);
428 print(FTy
->getReturnType(), OS
);
430 for (FunctionType::param_iterator I
= FTy
->param_begin(),
431 E
= FTy
->param_end(); I
!= E
; ++I
) {
432 if (I
!= FTy
->param_begin())
436 if (FTy
->isVarArg()) {
437 if (FTy
->getNumParams()) OS
<< ", ";
443 case Type::StructTyID
: {
444 StructType
*STy
= cast
<StructType
>(Ty
);
446 if (STy
->isLiteral())
447 return printStructBody(STy
, OS
);
449 if (!STy
->getName().empty())
450 return PrintLLVMName(OS
, STy
->getName(), LocalPrefix
);
452 DenseMap
<StructType
*, unsigned>::iterator I
= NumberedTypes
.find(STy
);
453 if (I
!= NumberedTypes
.end())
454 OS
<< '%' << I
->second
;
455 else // Not enumerated, print the hex address.
456 OS
<< "%\"type " << STy
<< '\"';
459 case Type::PointerTyID
: {
460 PointerType
*PTy
= cast
<PointerType
>(Ty
);
461 print(PTy
->getElementType(), OS
);
462 if (unsigned AddressSpace
= PTy
->getAddressSpace())
463 OS
<< " addrspace(" << AddressSpace
<< ')';
467 case Type::ArrayTyID
: {
468 ArrayType
*ATy
= cast
<ArrayType
>(Ty
);
469 OS
<< '[' << ATy
->getNumElements() << " x ";
470 print(ATy
->getElementType(), OS
);
474 case Type::VectorTyID
: {
475 VectorType
*PTy
= cast
<VectorType
>(Ty
);
476 OS
<< "<" << PTy
->getNumElements() << " x ";
477 print(PTy
->getElementType(), OS
);
482 llvm_unreachable("Invalid TypeID");
485 void TypePrinting::printStructBody(StructType
*STy
, raw_ostream
&OS
) {
486 if (STy
->isOpaque()) {
494 if (STy
->getNumElements() == 0) {
497 StructType::element_iterator I
= STy
->element_begin();
500 for (StructType::element_iterator E
= STy
->element_end(); I
!= E
; ++I
) {
511 //===----------------------------------------------------------------------===//
512 // SlotTracker Class: Enumerate slot numbers for unnamed values
513 //===----------------------------------------------------------------------===//
514 /// This class provides computation of slot numbers for LLVM Assembly writing.
518 /// ValueMap - A mapping of Values to slot numbers.
519 typedef DenseMap
<const Value
*, unsigned> ValueMap
;
522 /// TheModule - The module for which we are holding slot numbers.
523 const Module
* TheModule
;
525 /// TheFunction - The function for which we are holding slot numbers.
526 const Function
* TheFunction
;
527 bool FunctionProcessed
;
529 /// mMap - The slot map for the module level data.
533 /// fMap - The slot map for the function level data.
537 /// mdnMap - Map for MDNodes.
538 DenseMap
<const MDNode
*, unsigned> mdnMap
;
541 /// asMap - The slot map for attribute sets.
542 DenseMap
<AttributeSet
, unsigned> asMap
;
545 /// Construct from a module
546 explicit SlotTracker(const Module
*M
);
547 /// Construct from a function, starting out in incorp state.
548 explicit SlotTracker(const Function
*F
);
550 /// Return the slot number of the specified value in it's type
551 /// plane. If something is not in the SlotTracker, return -1.
552 int getLocalSlot(const Value
*V
);
553 int getGlobalSlot(const GlobalValue
*V
);
554 int getMetadataSlot(const MDNode
*N
);
555 int getAttributeGroupSlot(AttributeSet AS
);
557 /// If you'd like to deal with a function instead of just a module, use
558 /// this method to get its data into the SlotTracker.
559 void incorporateFunction(const Function
*F
) {
561 FunctionProcessed
= false;
564 const Function
*getFunction() const { return TheFunction
; }
566 /// After calling incorporateFunction, use this method to remove the
567 /// most recently incorporated function from the SlotTracker. This
568 /// will reset the state of the machine back to just the module contents.
569 void purgeFunction();
571 /// MDNode map iterators.
572 typedef DenseMap
<const MDNode
*, unsigned>::iterator mdn_iterator
;
573 mdn_iterator
mdn_begin() { return mdnMap
.begin(); }
574 mdn_iterator
mdn_end() { return mdnMap
.end(); }
575 unsigned mdn_size() const { return mdnMap
.size(); }
576 bool mdn_empty() const { return mdnMap
.empty(); }
578 /// AttributeSet map iterators.
579 typedef DenseMap
<AttributeSet
, unsigned>::iterator as_iterator
;
580 as_iterator
as_begin() { return asMap
.begin(); }
581 as_iterator
as_end() { return asMap
.end(); }
582 unsigned as_size() const { return asMap
.size(); }
583 bool as_empty() const { return asMap
.empty(); }
585 /// This function does the actual initialization.
586 inline void initialize();
588 // Implementation Details
590 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
591 void CreateModuleSlot(const GlobalValue
*V
);
593 /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
594 void CreateMetadataSlot(const MDNode
*N
);
596 /// CreateFunctionSlot - Insert the specified Value* into the slot table.
597 void CreateFunctionSlot(const Value
*V
);
599 /// \brief Insert the specified AttributeSet into the slot table.
600 void CreateAttributeSetSlot(AttributeSet AS
);
602 /// Add all of the module level global variables (and their initializers)
603 /// and function declarations, but not the contents of those functions.
604 void processModule();
606 /// Add all of the functions arguments, basic blocks, and instructions.
607 void processFunction();
609 SlotTracker(const SlotTracker
&) LLVM_DELETED_FUNCTION
;
610 void operator=(const SlotTracker
&) LLVM_DELETED_FUNCTION
;
613 SlotTracker
*createSlotTracker(const Module
*M
) {
614 return new SlotTracker(M
);
617 static SlotTracker
*createSlotTracker(const Value
*V
) {
618 if (const Argument
*FA
= dyn_cast
<Argument
>(V
))
619 return new SlotTracker(FA
->getParent());
621 if (const Instruction
*I
= dyn_cast
<Instruction
>(V
))
623 return new SlotTracker(I
->getParent()->getParent());
625 if (const BasicBlock
*BB
= dyn_cast
<BasicBlock
>(V
))
626 return new SlotTracker(BB
->getParent());
628 if (const GlobalVariable
*GV
= dyn_cast
<GlobalVariable
>(V
))
629 return new SlotTracker(GV
->getParent());
631 if (const GlobalAlias
*GA
= dyn_cast
<GlobalAlias
>(V
))
632 return new SlotTracker(GA
->getParent());
634 if (const Function
*Func
= dyn_cast
<Function
>(V
))
635 return new SlotTracker(Func
);
641 #define ST_DEBUG(X) dbgs() << X
646 // Module level constructor. Causes the contents of the Module (sans functions)
647 // to be added to the slot table.
648 SlotTracker::SlotTracker(const Module
*M
)
649 : TheModule(M
), TheFunction(nullptr), FunctionProcessed(false), mNext(0),
650 fNext(0), mdnNext(0), asNext(0) {}
652 // Function level constructor. Causes the contents of the Module and the one
653 // function provided to be added to the slot table.
654 SlotTracker::SlotTracker(const Function
*F
)
655 : TheModule(F
? F
->getParent() : nullptr), TheFunction(F
),
656 FunctionProcessed(false), mNext(0), fNext(0), mdnNext(0), asNext(0) {}
658 inline void SlotTracker::initialize() {
661 TheModule
= nullptr; ///< Prevent re-processing next time we're called.
664 if (TheFunction
&& !FunctionProcessed
)
668 // Iterate through all the global variables, functions, and global
669 // variable initializers and create slots for them.
670 void SlotTracker::processModule() {
671 ST_DEBUG("begin processModule!\n");
673 // Add all of the unnamed global variables to the value table.
674 for (Module::const_global_iterator I
= TheModule
->global_begin(),
675 E
= TheModule
->global_end(); I
!= E
; ++I
) {
680 // Add metadata used by named metadata.
681 for (Module::const_named_metadata_iterator
682 I
= TheModule
->named_metadata_begin(),
683 E
= TheModule
->named_metadata_end(); I
!= E
; ++I
) {
684 const NamedMDNode
*NMD
= I
;
685 for (unsigned i
= 0, e
= NMD
->getNumOperands(); i
!= e
; ++i
)
686 CreateMetadataSlot(NMD
->getOperand(i
));
689 for (Module::const_iterator I
= TheModule
->begin(), E
= TheModule
->end();
692 // Add all the unnamed functions to the table.
695 // Add all the function attributes to the table.
696 // FIXME: Add attributes of other objects?
697 AttributeSet FnAttrs
= I
->getAttributes().getFnAttributes();
698 if (FnAttrs
.hasAttributes(AttributeSet::FunctionIndex
))
699 CreateAttributeSetSlot(FnAttrs
);
702 ST_DEBUG("end processModule!\n");
705 // Process the arguments, basic blocks, and instructions of a function.
706 void SlotTracker::processFunction() {
707 ST_DEBUG("begin processFunction!\n");
710 // Add all the function arguments with no names.
711 for(Function::const_arg_iterator AI
= TheFunction
->arg_begin(),
712 AE
= TheFunction
->arg_end(); AI
!= AE
; ++AI
)
714 CreateFunctionSlot(AI
);
716 ST_DEBUG("Inserting Instructions:\n");
718 SmallVector
<std::pair
<unsigned, MDNode
*>, 4> MDForInst
;
720 // Add all of the basic blocks and instructions with no names.
721 for (Function::const_iterator BB
= TheFunction
->begin(),
722 E
= TheFunction
->end(); BB
!= E
; ++BB
) {
724 CreateFunctionSlot(BB
);
726 for (BasicBlock::const_iterator I
= BB
->begin(), E
= BB
->end(); I
!= E
;
728 if (!I
->getType()->isVoidTy() && !I
->hasName())
729 CreateFunctionSlot(I
);
731 // Intrinsics can directly use metadata. We allow direct calls to any
732 // llvm.foo function here, because the target may not be linked into the
734 if (const CallInst
*CI
= dyn_cast
<CallInst
>(I
)) {
735 if (Function
*F
= CI
->getCalledFunction())
736 if (F
->isIntrinsic())
737 for (unsigned i
= 0, e
= I
->getNumOperands(); i
!= e
; ++i
)
738 if (auto *V
= dyn_cast_or_null
<MetadataAsValue
>(I
->getOperand(i
)))
739 if (MDNode
*N
= dyn_cast
<MDNode
>(V
->getMetadata()))
740 CreateMetadataSlot(N
);
742 // Add all the call attributes to the table.
743 AttributeSet Attrs
= CI
->getAttributes().getFnAttributes();
744 if (Attrs
.hasAttributes(AttributeSet::FunctionIndex
))
745 CreateAttributeSetSlot(Attrs
);
746 } else if (const InvokeInst
*II
= dyn_cast
<InvokeInst
>(I
)) {
747 // Add all the call attributes to the table.
748 AttributeSet Attrs
= II
->getAttributes().getFnAttributes();
749 if (Attrs
.hasAttributes(AttributeSet::FunctionIndex
))
750 CreateAttributeSetSlot(Attrs
);
753 // Process metadata attached with this instruction.
754 I
->getAllMetadata(MDForInst
);
755 for (unsigned i
= 0, e
= MDForInst
.size(); i
!= e
; ++i
)
756 CreateMetadataSlot(MDForInst
[i
].second
);
761 FunctionProcessed
= true;
763 ST_DEBUG("end processFunction!\n");
766 /// Clean up after incorporating a function. This is the only way to get out of
767 /// the function incorporation state that affects get*Slot/Create*Slot. Function
768 /// incorporation state is indicated by TheFunction != 0.
769 void SlotTracker::purgeFunction() {
770 ST_DEBUG("begin purgeFunction!\n");
771 fMap
.clear(); // Simply discard the function level map
772 TheFunction
= nullptr;
773 FunctionProcessed
= false;
774 ST_DEBUG("end purgeFunction!\n");
777 /// getGlobalSlot - Get the slot number of a global value.
778 int SlotTracker::getGlobalSlot(const GlobalValue
*V
) {
779 // Check for uninitialized state and do lazy initialization.
782 // Find the value in the module map
783 ValueMap::iterator MI
= mMap
.find(V
);
784 return MI
== mMap
.end() ? -1 : (int)MI
->second
;
787 /// getMetadataSlot - Get the slot number of a MDNode.
788 int SlotTracker::getMetadataSlot(const MDNode
*N
) {
789 // Check for uninitialized state and do lazy initialization.
792 // Find the MDNode in the module map
793 mdn_iterator MI
= mdnMap
.find(N
);
794 return MI
== mdnMap
.end() ? -1 : (int)MI
->second
;
798 /// getLocalSlot - Get the slot number for a value that is local to a function.
799 int SlotTracker::getLocalSlot(const Value
*V
) {
800 assert(!isa
<Constant
>(V
) && "Can't get a constant or global slot with this!");
802 // Check for uninitialized state and do lazy initialization.
805 ValueMap::iterator FI
= fMap
.find(V
);
806 return FI
== fMap
.end() ? -1 : (int)FI
->second
;
809 int SlotTracker::getAttributeGroupSlot(AttributeSet AS
) {
810 // Check for uninitialized state and do lazy initialization.
813 // Find the AttributeSet in the module map.
814 as_iterator AI
= asMap
.find(AS
);
815 return AI
== asMap
.end() ? -1 : (int)AI
->second
;
818 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
819 void SlotTracker::CreateModuleSlot(const GlobalValue
*V
) {
820 assert(V
&& "Can't insert a null Value into SlotTracker!");
821 assert(!V
->getType()->isVoidTy() && "Doesn't need a slot!");
822 assert(!V
->hasName() && "Doesn't need a slot!");
824 unsigned DestSlot
= mNext
++;
827 ST_DEBUG(" Inserting value [" << V
->getType() << "] = " << V
<< " slot=" <<
829 // G = Global, F = Function, A = Alias, o = other
830 ST_DEBUG((isa
<GlobalVariable
>(V
) ? 'G' :
831 (isa
<Function
>(V
) ? 'F' :
832 (isa
<GlobalAlias
>(V
) ? 'A' : 'o'))) << "]\n");
835 /// CreateSlot - Create a new slot for the specified value if it has no name.
836 void SlotTracker::CreateFunctionSlot(const Value
*V
) {
837 assert(!V
->getType()->isVoidTy() && !V
->hasName() && "Doesn't need a slot!");
839 unsigned DestSlot
= fNext
++;
842 // G = Global, F = Function, o = other
843 ST_DEBUG(" Inserting value [" << V
->getType() << "] = " << V
<< " slot=" <<
844 DestSlot
<< " [o]\n");
847 /// CreateModuleSlot - Insert the specified MDNode* into the slot table.
848 void SlotTracker::CreateMetadataSlot(const MDNode
*N
) {
849 assert(N
&& "Can't insert a null Value into SlotTracker!");
851 unsigned DestSlot
= mdnNext
;
852 if (!mdnMap
.insert(std::make_pair(N
, DestSlot
)).second
)
856 // Recursively add any MDNodes referenced by operands.
857 for (unsigned i
= 0, e
= N
->getNumOperands(); i
!= e
; ++i
)
858 if (const MDNode
*Op
= dyn_cast_or_null
<MDNode
>(N
->getOperand(i
)))
859 CreateMetadataSlot(Op
);
862 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS
) {
863 assert(AS
.hasAttributes(AttributeSet::FunctionIndex
) &&
864 "Doesn't need a slot!");
866 as_iterator I
= asMap
.find(AS
);
867 if (I
!= asMap
.end())
870 unsigned DestSlot
= asNext
++;
871 asMap
[AS
] = DestSlot
;
874 //===----------------------------------------------------------------------===//
875 // AsmWriter Implementation
876 //===----------------------------------------------------------------------===//
878 static void WriteAsOperandInternal(raw_ostream
&Out
, const Value
*V
,
879 TypePrinting
*TypePrinter
,
880 SlotTracker
*Machine
,
881 const Module
*Context
);
883 static void WriteAsOperandInternal(raw_ostream
&Out
, const Metadata
*MD
,
884 TypePrinting
*TypePrinter
,
885 SlotTracker
*Machine
, const Module
*Context
,
886 bool FromValue
= false);
888 static const char *getPredicateText(unsigned predicate
) {
889 const char * pred
= "unknown";
891 case FCmpInst::FCMP_FALSE
: pred
= "false"; break;
892 case FCmpInst::FCMP_OEQ
: pred
= "oeq"; break;
893 case FCmpInst::FCMP_OGT
: pred
= "ogt"; break;
894 case FCmpInst::FCMP_OGE
: pred
= "oge"; break;
895 case FCmpInst::FCMP_OLT
: pred
= "olt"; break;
896 case FCmpInst::FCMP_OLE
: pred
= "ole"; break;
897 case FCmpInst::FCMP_ONE
: pred
= "one"; break;
898 case FCmpInst::FCMP_ORD
: pred
= "ord"; break;
899 case FCmpInst::FCMP_UNO
: pred
= "uno"; break;
900 case FCmpInst::FCMP_UEQ
: pred
= "ueq"; break;
901 case FCmpInst::FCMP_UGT
: pred
= "ugt"; break;
902 case FCmpInst::FCMP_UGE
: pred
= "uge"; break;
903 case FCmpInst::FCMP_ULT
: pred
= "ult"; break;
904 case FCmpInst::FCMP_ULE
: pred
= "ule"; break;
905 case FCmpInst::FCMP_UNE
: pred
= "une"; break;
906 case FCmpInst::FCMP_TRUE
: pred
= "true"; break;
907 case ICmpInst::ICMP_EQ
: pred
= "eq"; break;
908 case ICmpInst::ICMP_NE
: pred
= "ne"; break;
909 case ICmpInst::ICMP_SGT
: pred
= "sgt"; break;
910 case ICmpInst::ICMP_SGE
: pred
= "sge"; break;
911 case ICmpInst::ICMP_SLT
: pred
= "slt"; break;
912 case ICmpInst::ICMP_SLE
: pred
= "sle"; break;
913 case ICmpInst::ICMP_UGT
: pred
= "ugt"; break;
914 case ICmpInst::ICMP_UGE
: pred
= "uge"; break;
915 case ICmpInst::ICMP_ULT
: pred
= "ult"; break;
916 case ICmpInst::ICMP_ULE
: pred
= "ule"; break;
921 static void writeAtomicRMWOperation(raw_ostream
&Out
,
922 AtomicRMWInst::BinOp Op
) {
924 default: Out
<< " <unknown operation " << Op
<< ">"; break;
925 case AtomicRMWInst::Xchg
: Out
<< " xchg"; break;
926 case AtomicRMWInst::Add
: Out
<< " add"; break;
927 case AtomicRMWInst::Sub
: Out
<< " sub"; break;
928 case AtomicRMWInst::And
: Out
<< " and"; break;
929 case AtomicRMWInst::Nand
: Out
<< " nand"; break;
930 case AtomicRMWInst::Or
: Out
<< " or"; break;
931 case AtomicRMWInst::Xor
: Out
<< " xor"; break;
932 case AtomicRMWInst::Max
: Out
<< " max"; break;
933 case AtomicRMWInst::Min
: Out
<< " min"; break;
934 case AtomicRMWInst::UMax
: Out
<< " umax"; break;
935 case AtomicRMWInst::UMin
: Out
<< " umin"; break;
939 static void WriteOptimizationInfo(raw_ostream
&Out
, const User
*U
) {
940 if (const FPMathOperator
*FPO
= dyn_cast
<const FPMathOperator
>(U
)) {
941 // Unsafe algebra implies all the others, no need to write them all out
942 if (FPO
->hasUnsafeAlgebra())
945 if (FPO
->hasNoNaNs())
947 if (FPO
->hasNoInfs())
949 if (FPO
->hasNoSignedZeros())
951 if (FPO
->hasAllowReciprocal())
956 if (const OverflowingBinaryOperator
*OBO
=
957 dyn_cast
<OverflowingBinaryOperator
>(U
)) {
958 if (OBO
->hasNoUnsignedWrap())
960 if (OBO
->hasNoSignedWrap())
962 } else if (const PossiblyExactOperator
*Div
=
963 dyn_cast
<PossiblyExactOperator
>(U
)) {
966 } else if (const GEPOperator
*GEP
= dyn_cast
<GEPOperator
>(U
)) {
967 if (GEP
->isInBounds())
972 static void WriteConstantInternal(raw_ostream
&Out
, const Constant
*CV
,
973 TypePrinting
&TypePrinter
,
974 SlotTracker
*Machine
,
975 const Module
*Context
) {
976 if (const ConstantInt
*CI
= dyn_cast
<ConstantInt
>(CV
)) {
977 if (CI
->getType()->isIntegerTy(1)) {
978 Out
<< (CI
->getZExtValue() ? "true" : "false");
981 Out
<< CI
->getValue();
985 if (const ConstantFP
*CFP
= dyn_cast
<ConstantFP
>(CV
)) {
986 if (&CFP
->getValueAPF().getSemantics() == &APFloat::IEEEsingle
||
987 &CFP
->getValueAPF().getSemantics() == &APFloat::IEEEdouble
) {
988 // We would like to output the FP constant value in exponential notation,
989 // but we cannot do this if doing so will lose precision. Check here to
990 // make sure that we only output it in exponential format if we can parse
991 // the value back and get the same value.
994 bool isHalf
= &CFP
->getValueAPF().getSemantics()==&APFloat::IEEEhalf
;
995 bool isDouble
= &CFP
->getValueAPF().getSemantics()==&APFloat::IEEEdouble
;
996 bool isInf
= CFP
->getValueAPF().isInfinity();
997 bool isNaN
= CFP
->getValueAPF().isNaN();
998 if (!isHalf
&& !isInf
&& !isNaN
) {
999 double Val
= isDouble
? CFP
->getValueAPF().convertToDouble() :
1000 CFP
->getValueAPF().convertToFloat();
1001 SmallString
<128> StrVal
;
1002 raw_svector_ostream(StrVal
) << Val
;
1004 // Check to make sure that the stringized number is not some string like
1005 // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1006 // that the string matches the "[-+]?[0-9]" regex.
1008 if ((StrVal
[0] >= '0' && StrVal
[0] <= '9') ||
1009 ((StrVal
[0] == '-' || StrVal
[0] == '+') &&
1010 (StrVal
[1] >= '0' && StrVal
[1] <= '9'))) {
1011 // Reparse stringized version!
1012 if (APFloat(APFloat::IEEEdouble
, StrVal
).convertToDouble() == Val
) {
1013 Out
<< StrVal
.str();
1018 // Otherwise we could not reparse it to exactly the same value, so we must
1019 // output the string in hexadecimal format! Note that loading and storing
1020 // floating point types changes the bits of NaNs on some hosts, notably
1021 // x86, so we must not use these types.
1022 static_assert(sizeof(double) == sizeof(uint64_t),
1023 "assuming that double is 64 bits!");
1025 APFloat apf
= CFP
->getValueAPF();
1026 // Halves and floats are represented in ASCII IR as double, convert.
1028 apf
.convert(APFloat::IEEEdouble
, APFloat::rmNearestTiesToEven
,
1031 utohex_buffer(uint64_t(apf
.bitcastToAPInt().getZExtValue()),
1036 // Either half, or some form of long double.
1037 // These appear as a magic letter identifying the type, then a
1038 // fixed number of hex digits.
1040 // Bit position, in the current word, of the next nibble to print.
1043 if (&CFP
->getValueAPF().getSemantics() == &APFloat::x87DoubleExtended
) {
1045 // api needed to prevent premature destruction
1046 APInt api
= CFP
->getValueAPF().bitcastToAPInt();
1047 const uint64_t* p
= api
.getRawData();
1048 uint64_t word
= p
[1];
1050 int width
= api
.getBitWidth();
1051 for (int j
=0; j
<width
; j
+=4, shiftcount
-=4) {
1052 unsigned int nibble
= (word
>>shiftcount
) & 15;
1054 Out
<< (unsigned char)(nibble
+ '0');
1056 Out
<< (unsigned char)(nibble
- 10 + 'A');
1057 if (shiftcount
== 0 && j
+4 < width
) {
1061 shiftcount
= width
-j
-4;
1065 } else if (&CFP
->getValueAPF().getSemantics() == &APFloat::IEEEquad
) {
1068 } else if (&CFP
->getValueAPF().getSemantics() == &APFloat::PPCDoubleDouble
) {
1071 } else if (&CFP
->getValueAPF().getSemantics() == &APFloat::IEEEhalf
) {
1075 llvm_unreachable("Unsupported floating point type");
1076 // api needed to prevent premature destruction
1077 APInt api
= CFP
->getValueAPF().bitcastToAPInt();
1078 const uint64_t* p
= api
.getRawData();
1080 int width
= api
.getBitWidth();
1081 for (int j
=0; j
<width
; j
+=4, shiftcount
-=4) {
1082 unsigned int nibble
= (word
>>shiftcount
) & 15;
1084 Out
<< (unsigned char)(nibble
+ '0');
1086 Out
<< (unsigned char)(nibble
- 10 + 'A');
1087 if (shiftcount
== 0 && j
+4 < width
) {
1091 shiftcount
= width
-j
-4;
1097 if (isa
<ConstantAggregateZero
>(CV
)) {
1098 Out
<< "zeroinitializer";
1102 if (const BlockAddress
*BA
= dyn_cast
<BlockAddress
>(CV
)) {
1103 Out
<< "blockaddress(";
1104 WriteAsOperandInternal(Out
, BA
->getFunction(), &TypePrinter
, Machine
,
1107 WriteAsOperandInternal(Out
, BA
->getBasicBlock(), &TypePrinter
, Machine
,
1113 if (const ConstantArray
*CA
= dyn_cast
<ConstantArray
>(CV
)) {
1114 Type
*ETy
= CA
->getType()->getElementType();
1116 TypePrinter
.print(ETy
, Out
);
1118 WriteAsOperandInternal(Out
, CA
->getOperand(0),
1119 &TypePrinter
, Machine
,
1121 for (unsigned i
= 1, e
= CA
->getNumOperands(); i
!= e
; ++i
) {
1123 TypePrinter
.print(ETy
, Out
);
1125 WriteAsOperandInternal(Out
, CA
->getOperand(i
), &TypePrinter
, Machine
,
1132 if (const ConstantDataArray
*CA
= dyn_cast
<ConstantDataArray
>(CV
)) {
1133 // As a special case, print the array as a string if it is an array of
1134 // i8 with ConstantInt values.
1135 if (CA
->isString()) {
1137 PrintEscapedString(CA
->getAsString(), Out
);
1142 Type
*ETy
= CA
->getType()->getElementType();
1144 TypePrinter
.print(ETy
, Out
);
1146 WriteAsOperandInternal(Out
, CA
->getElementAsConstant(0),
1147 &TypePrinter
, Machine
,
1149 for (unsigned i
= 1, e
= CA
->getNumElements(); i
!= e
; ++i
) {
1151 TypePrinter
.print(ETy
, Out
);
1153 WriteAsOperandInternal(Out
, CA
->getElementAsConstant(i
), &TypePrinter
,
1161 if (const ConstantStruct
*CS
= dyn_cast
<ConstantStruct
>(CV
)) {
1162 if (CS
->getType()->isPacked())
1165 unsigned N
= CS
->getNumOperands();
1168 TypePrinter
.print(CS
->getOperand(0)->getType(), Out
);
1171 WriteAsOperandInternal(Out
, CS
->getOperand(0), &TypePrinter
, Machine
,
1174 for (unsigned i
= 1; i
< N
; i
++) {
1176 TypePrinter
.print(CS
->getOperand(i
)->getType(), Out
);
1179 WriteAsOperandInternal(Out
, CS
->getOperand(i
), &TypePrinter
, Machine
,
1186 if (CS
->getType()->isPacked())
1191 if (isa
<ConstantVector
>(CV
) || isa
<ConstantDataVector
>(CV
)) {
1192 Type
*ETy
= CV
->getType()->getVectorElementType();
1194 TypePrinter
.print(ETy
, Out
);
1196 WriteAsOperandInternal(Out
, CV
->getAggregateElement(0U), &TypePrinter
,
1198 for (unsigned i
= 1, e
= CV
->getType()->getVectorNumElements(); i
!= e
;++i
){
1200 TypePrinter
.print(ETy
, Out
);
1202 WriteAsOperandInternal(Out
, CV
->getAggregateElement(i
), &TypePrinter
,
1209 if (isa
<ConstantPointerNull
>(CV
)) {
1214 if (isa
<UndefValue
>(CV
)) {
1219 if (const ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(CV
)) {
1220 Out
<< CE
->getOpcodeName();
1221 WriteOptimizationInfo(Out
, CE
);
1222 if (CE
->isCompare())
1223 Out
<< ' ' << getPredicateText(CE
->getPredicate());
1226 for (User::const_op_iterator OI
=CE
->op_begin(); OI
!= CE
->op_end(); ++OI
) {
1227 TypePrinter
.print((*OI
)->getType(), Out
);
1229 WriteAsOperandInternal(Out
, *OI
, &TypePrinter
, Machine
, Context
);
1230 if (OI
+1 != CE
->op_end())
1234 if (CE
->hasIndices()) {
1235 ArrayRef
<unsigned> Indices
= CE
->getIndices();
1236 for (unsigned i
= 0, e
= Indices
.size(); i
!= e
; ++i
)
1237 Out
<< ", " << Indices
[i
];
1242 TypePrinter
.print(CE
->getType(), Out
);
1249 Out
<< "<placeholder or erroneous Constant>";
1252 static void writeMDTuple(raw_ostream
&Out
, const MDTuple
*Node
,
1253 TypePrinting
*TypePrinter
, SlotTracker
*Machine
,
1254 const Module
*Context
) {
1256 for (unsigned mi
= 0, me
= Node
->getNumOperands(); mi
!= me
; ++mi
) {
1257 const Metadata
*MD
= Node
->getOperand(mi
);
1260 else if (auto *MDV
= dyn_cast
<ValueAsMetadata
>(MD
)) {
1261 Value
*V
= MDV
->getValue();
1262 TypePrinter
->print(V
->getType(), Out
);
1264 WriteAsOperandInternal(Out
, V
, TypePrinter
, Machine
, Context
);
1266 WriteAsOperandInternal(Out
, MD
, TypePrinter
, Machine
, Context
);
1276 struct FieldSeparator
{
1278 FieldSeparator() : Skip(true) {}
1280 raw_ostream
&operator<<(raw_ostream
&OS
, FieldSeparator
&FS
) {
1289 static void writeMDLocation(raw_ostream
&Out
, const MDLocation
*DL
,
1290 TypePrinting
*TypePrinter
, SlotTracker
*Machine
,
1291 const Module
*Context
) {
1292 Out
<< "!MDLocation(";
1294 // Always output the line, since 0 is a relevant and important value for it.
1295 Out
<< FS
<< "line: " << DL
->getLine();
1296 if (DL
->getColumn())
1297 Out
<< FS
<< "column: " << DL
->getColumn();
1298 Out
<< FS
<< "scope: ";
1299 WriteAsOperandInternal(Out
, DL
->getScope(), TypePrinter
, Machine
, Context
);
1300 if (DL
->getInlinedAt()) {
1301 Out
<< FS
<< "inlinedAt: ";
1302 WriteAsOperandInternal(Out
, DL
->getInlinedAt(), TypePrinter
, Machine
,
1308 static void WriteMDNodeBodyInternal(raw_ostream
&Out
, const MDNode
*Node
,
1309 TypePrinting
*TypePrinter
,
1310 SlotTracker
*Machine
,
1311 const Module
*Context
) {
1312 assert(isa
<UniquableMDNode
>(Node
) && "Expected uniquable MDNode");
1314 auto *Uniquable
= cast
<UniquableMDNode
>(Node
);
1315 if (Uniquable
->isDistinct())
1318 switch (Uniquable
->getMetadataID()) {
1320 llvm_unreachable("Expected uniquable MDNode");
1321 #define HANDLE_UNIQUABLE_LEAF(CLASS) \
1322 case Metadata::CLASS##Kind: \
1323 write##CLASS(Out, cast<CLASS>(Uniquable), TypePrinter, Machine, Context); \
1325 #include "llvm/IR/Metadata.def"
1329 // Full implementation of printing a Value as an operand with support for
1330 // TypePrinting, etc.
1331 static void WriteAsOperandInternal(raw_ostream
&Out
, const Value
*V
,
1332 TypePrinting
*TypePrinter
,
1333 SlotTracker
*Machine
,
1334 const Module
*Context
) {
1336 PrintLLVMName(Out
, V
);
1340 const Constant
*CV
= dyn_cast
<Constant
>(V
);
1341 if (CV
&& !isa
<GlobalValue
>(CV
)) {
1342 assert(TypePrinter
&& "Constants require TypePrinting!");
1343 WriteConstantInternal(Out
, CV
, *TypePrinter
, Machine
, Context
);
1347 if (const InlineAsm
*IA
= dyn_cast
<InlineAsm
>(V
)) {
1349 if (IA
->hasSideEffects())
1350 Out
<< "sideeffect ";
1351 if (IA
->isAlignStack())
1352 Out
<< "alignstack ";
1353 // We don't emit the AD_ATT dialect as it's the assumed default.
1354 if (IA
->getDialect() == InlineAsm::AD_Intel
)
1355 Out
<< "inteldialect ";
1357 PrintEscapedString(IA
->getAsmString(), Out
);
1359 PrintEscapedString(IA
->getConstraintString(), Out
);
1364 if (auto *MD
= dyn_cast
<MetadataAsValue
>(V
)) {
1365 WriteAsOperandInternal(Out
, MD
->getMetadata(), TypePrinter
, Machine
,
1366 Context
, /* FromValue */ true);
1372 // If we have a SlotTracker, use it.
1374 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(V
)) {
1375 Slot
= Machine
->getGlobalSlot(GV
);
1378 Slot
= Machine
->getLocalSlot(V
);
1380 // If the local value didn't succeed, then we may be referring to a value
1381 // from a different function. Translate it, as this can happen when using
1382 // address of blocks.
1384 if ((Machine
= createSlotTracker(V
))) {
1385 Slot
= Machine
->getLocalSlot(V
);
1389 } else if ((Machine
= createSlotTracker(V
))) {
1390 // Otherwise, create one to get the # and then destroy it.
1391 if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(V
)) {
1392 Slot
= Machine
->getGlobalSlot(GV
);
1395 Slot
= Machine
->getLocalSlot(V
);
1404 Out
<< Prefix
<< Slot
;
1409 static void WriteAsOperandInternal(raw_ostream
&Out
, const Metadata
*MD
,
1410 TypePrinting
*TypePrinter
,
1411 SlotTracker
*Machine
, const Module
*Context
,
1413 if (const MDNode
*N
= dyn_cast
<MDNode
>(MD
)) {
1415 Machine
= new SlotTracker(Context
);
1416 int Slot
= Machine
->getMetadataSlot(N
);
1418 // Give the pointer value instead of "badref", since this comes up all
1419 // the time when debugging.
1420 Out
<< "<" << N
<< ">";
1426 if (const MDString
*MDS
= dyn_cast
<MDString
>(MD
)) {
1428 PrintEscapedString(MDS
->getString(), Out
);
1433 auto *V
= cast
<ValueAsMetadata
>(MD
);
1434 assert(TypePrinter
&& "TypePrinter required for metadata values");
1435 assert((FromValue
|| !isa
<LocalAsMetadata
>(V
)) &&
1436 "Unexpected function-local metadata outside of value argument");
1438 TypePrinter
->print(V
->getValue()->getType(), Out
);
1440 WriteAsOperandInternal(Out
, V
->getValue(), TypePrinter
, Machine
, Context
);
1443 void AssemblyWriter::init() {
1446 TypePrinter
.incorporateTypes(*TheModule
);
1447 for (const Function
&F
: *TheModule
)
1448 if (const Comdat
*C
= F
.getComdat())
1450 for (const GlobalVariable
&GV
: TheModule
->globals())
1451 if (const Comdat
*C
= GV
.getComdat())
1456 AssemblyWriter::AssemblyWriter(formatted_raw_ostream
&o
, SlotTracker
&Mac
,
1458 AssemblyAnnotationWriter
*AAW
)
1459 : Out(o
), TheModule(M
), Machine(Mac
), AnnotationWriter(AAW
) {
1463 AssemblyWriter::AssemblyWriter(formatted_raw_ostream
&o
, const Module
*M
,
1464 AssemblyAnnotationWriter
*AAW
)
1465 : Out(o
), TheModule(M
), ModuleSlotTracker(createSlotTracker(M
)),
1466 Machine(*ModuleSlotTracker
), AnnotationWriter(AAW
) {
1470 AssemblyWriter::~AssemblyWriter() { }
1472 void AssemblyWriter::writeOperand(const Value
*Operand
, bool PrintType
) {
1474 Out
<< "<null operand!>";
1478 TypePrinter
.print(Operand
->getType(), Out
);
1481 WriteAsOperandInternal(Out
, Operand
, &TypePrinter
, &Machine
, TheModule
);
1484 void AssemblyWriter::writeAtomic(AtomicOrdering Ordering
,
1485 SynchronizationScope SynchScope
) {
1486 if (Ordering
== NotAtomic
)
1489 switch (SynchScope
) {
1490 case SingleThread
: Out
<< " singlethread"; break;
1491 case CrossThread
: break;
1495 default: Out
<< " <bad ordering " << int(Ordering
) << ">"; break;
1496 case Unordered
: Out
<< " unordered"; break;
1497 case Monotonic
: Out
<< " monotonic"; break;
1498 case Acquire
: Out
<< " acquire"; break;
1499 case Release
: Out
<< " release"; break;
1500 case AcquireRelease
: Out
<< " acq_rel"; break;
1501 case SequentiallyConsistent
: Out
<< " seq_cst"; break;
1505 void AssemblyWriter::writeAtomicCmpXchg(AtomicOrdering SuccessOrdering
,
1506 AtomicOrdering FailureOrdering
,
1507 SynchronizationScope SynchScope
) {
1508 assert(SuccessOrdering
!= NotAtomic
&& FailureOrdering
!= NotAtomic
);
1510 switch (SynchScope
) {
1511 case SingleThread
: Out
<< " singlethread"; break;
1512 case CrossThread
: break;
1515 switch (SuccessOrdering
) {
1516 default: Out
<< " <bad ordering " << int(SuccessOrdering
) << ">"; break;
1517 case Unordered
: Out
<< " unordered"; break;
1518 case Monotonic
: Out
<< " monotonic"; break;
1519 case Acquire
: Out
<< " acquire"; break;
1520 case Release
: Out
<< " release"; break;
1521 case AcquireRelease
: Out
<< " acq_rel"; break;
1522 case SequentiallyConsistent
: Out
<< " seq_cst"; break;
1525 switch (FailureOrdering
) {
1526 default: Out
<< " <bad ordering " << int(FailureOrdering
) << ">"; break;
1527 case Unordered
: Out
<< " unordered"; break;
1528 case Monotonic
: Out
<< " monotonic"; break;
1529 case Acquire
: Out
<< " acquire"; break;
1530 case Release
: Out
<< " release"; break;
1531 case AcquireRelease
: Out
<< " acq_rel"; break;
1532 case SequentiallyConsistent
: Out
<< " seq_cst"; break;
1536 void AssemblyWriter::writeParamOperand(const Value
*Operand
,
1537 AttributeSet Attrs
, unsigned Idx
) {
1539 Out
<< "<null operand!>";
1544 TypePrinter
.print(Operand
->getType(), Out
);
1545 // Print parameter attributes list
1546 if (Attrs
.hasAttributes(Idx
))
1547 Out
<< ' ' << Attrs
.getAsString(Idx
);
1549 // Print the operand
1550 WriteAsOperandInternal(Out
, Operand
, &TypePrinter
, &Machine
, TheModule
);
1553 void AssemblyWriter::printModule(const Module
*M
) {
1554 Machine
.initialize();
1556 if (shouldPreserveAssemblyUseListOrder())
1557 UseListOrders
= predictUseListOrder(M
);
1559 if (!M
->getModuleIdentifier().empty() &&
1560 // Don't print the ID if it will start a new line (which would
1561 // require a comment char before it).
1562 M
->getModuleIdentifier().find('\n') == std::string::npos
)
1563 Out
<< "; ModuleID = '" << M
->getModuleIdentifier() << "'\n";
1565 const std::string
&DL
= M
->getDataLayoutStr();
1567 Out
<< "target datalayout = \"" << DL
<< "\"\n";
1568 if (!M
->getTargetTriple().empty())
1569 Out
<< "target triple = \"" << M
->getTargetTriple() << "\"\n";
1571 if (!M
->getModuleInlineAsm().empty()) {
1572 // Split the string into lines, to make it easier to read the .ll file.
1573 std::string Asm
= M
->getModuleInlineAsm();
1575 size_t NewLine
= Asm
.find_first_of('\n', CurPos
);
1577 while (NewLine
!= std::string::npos
) {
1578 // We found a newline, print the portion of the asm string from the
1579 // last newline up to this newline.
1580 Out
<< "module asm \"";
1581 PrintEscapedString(std::string(Asm
.begin()+CurPos
, Asm
.begin()+NewLine
),
1585 NewLine
= Asm
.find_first_of('\n', CurPos
);
1587 std::string
rest(Asm
.begin()+CurPos
, Asm
.end());
1588 if (!rest
.empty()) {
1589 Out
<< "module asm \"";
1590 PrintEscapedString(rest
, Out
);
1595 printTypeIdentities();
1597 // Output all comdats.
1598 if (!Comdats
.empty())
1600 for (const Comdat
*C
: Comdats
) {
1602 if (C
!= Comdats
.back())
1606 // Output all globals.
1607 if (!M
->global_empty()) Out
<< '\n';
1608 for (Module::const_global_iterator I
= M
->global_begin(), E
= M
->global_end();
1610 printGlobal(I
); Out
<< '\n';
1613 // Output all aliases.
1614 if (!M
->alias_empty()) Out
<< "\n";
1615 for (Module::const_alias_iterator I
= M
->alias_begin(), E
= M
->alias_end();
1619 // Output global use-lists.
1620 printUseLists(nullptr);
1622 // Output all of the functions.
1623 for (Module::const_iterator I
= M
->begin(), E
= M
->end(); I
!= E
; ++I
)
1625 assert(UseListOrders
.empty() && "All use-lists should have been consumed");
1627 // Output all attribute groups.
1628 if (!Machine
.as_empty()) {
1630 writeAllAttributeGroups();
1633 // Output named metadata.
1634 if (!M
->named_metadata_empty()) Out
<< '\n';
1636 for (Module::const_named_metadata_iterator I
= M
->named_metadata_begin(),
1637 E
= M
->named_metadata_end(); I
!= E
; ++I
)
1638 printNamedMDNode(I
);
1641 if (!Machine
.mdn_empty()) {
1647 void AssemblyWriter::printNamedMDNode(const NamedMDNode
*NMD
) {
1649 StringRef Name
= NMD
->getName();
1651 Out
<< "<empty name> ";
1653 if (isalpha(static_cast<unsigned char>(Name
[0])) ||
1654 Name
[0] == '-' || Name
[0] == '$' ||
1655 Name
[0] == '.' || Name
[0] == '_')
1658 Out
<< '\\' << hexdigit(Name
[0] >> 4) << hexdigit(Name
[0] & 0x0F);
1659 for (unsigned i
= 1, e
= Name
.size(); i
!= e
; ++i
) {
1660 unsigned char C
= Name
[i
];
1661 if (isalnum(static_cast<unsigned char>(C
)) || C
== '-' || C
== '$' ||
1662 C
== '.' || C
== '_')
1665 Out
<< '\\' << hexdigit(C
>> 4) << hexdigit(C
& 0x0F);
1669 for (unsigned i
= 0, e
= NMD
->getNumOperands(); i
!= e
; ++i
) {
1671 int Slot
= Machine
.getMetadataSlot(NMD
->getOperand(i
));
1681 static void PrintLinkage(GlobalValue::LinkageTypes LT
,
1682 formatted_raw_ostream
&Out
) {
1684 case GlobalValue::ExternalLinkage
: break;
1685 case GlobalValue::PrivateLinkage
: Out
<< "private "; break;
1686 case GlobalValue::InternalLinkage
: Out
<< "internal "; break;
1687 case GlobalValue::LinkOnceAnyLinkage
: Out
<< "linkonce "; break;
1688 case GlobalValue::LinkOnceODRLinkage
: Out
<< "linkonce_odr "; break;
1689 case GlobalValue::WeakAnyLinkage
: Out
<< "weak "; break;
1690 case GlobalValue::WeakODRLinkage
: Out
<< "weak_odr "; break;
1691 case GlobalValue::CommonLinkage
: Out
<< "common "; break;
1692 case GlobalValue::AppendingLinkage
: Out
<< "appending "; break;
1693 case GlobalValue::ExternalWeakLinkage
: Out
<< "extern_weak "; break;
1694 case GlobalValue::AvailableExternallyLinkage
:
1695 Out
<< "available_externally ";
1701 static void PrintVisibility(GlobalValue::VisibilityTypes Vis
,
1702 formatted_raw_ostream
&Out
) {
1704 case GlobalValue::DefaultVisibility
: break;
1705 case GlobalValue::HiddenVisibility
: Out
<< "hidden "; break;
1706 case GlobalValue::ProtectedVisibility
: Out
<< "protected "; break;
1710 static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT
,
1711 formatted_raw_ostream
&Out
) {
1713 case GlobalValue::DefaultStorageClass
: break;
1714 case GlobalValue::DLLImportStorageClass
: Out
<< "dllimport "; break;
1715 case GlobalValue::DLLExportStorageClass
: Out
<< "dllexport "; break;
1719 static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM
,
1720 formatted_raw_ostream
&Out
) {
1722 case GlobalVariable::NotThreadLocal
:
1724 case GlobalVariable::GeneralDynamicTLSModel
:
1725 Out
<< "thread_local ";
1727 case GlobalVariable::LocalDynamicTLSModel
:
1728 Out
<< "thread_local(localdynamic) ";
1730 case GlobalVariable::InitialExecTLSModel
:
1731 Out
<< "thread_local(initialexec) ";
1733 case GlobalVariable::LocalExecTLSModel
:
1734 Out
<< "thread_local(localexec) ";
1739 static void maybePrintComdat(formatted_raw_ostream
&Out
,
1740 const GlobalObject
&GO
) {
1741 const Comdat
*C
= GO
.getComdat();
1745 if (isa
<GlobalVariable
>(GO
))
1749 if (GO
.getName() == C
->getName())
1753 PrintLLVMName(Out
, C
->getName(), ComdatPrefix
);
1757 void AssemblyWriter::printGlobal(const GlobalVariable
*GV
) {
1758 if (GV
->isMaterializable())
1759 Out
<< "; Materializable\n";
1761 WriteAsOperandInternal(Out
, GV
, &TypePrinter
, &Machine
, GV
->getParent());
1764 if (!GV
->hasInitializer() && GV
->hasExternalLinkage())
1767 PrintLinkage(GV
->getLinkage(), Out
);
1768 PrintVisibility(GV
->getVisibility(), Out
);
1769 PrintDLLStorageClass(GV
->getDLLStorageClass(), Out
);
1770 PrintThreadLocalModel(GV
->getThreadLocalMode(), Out
);
1771 if (GV
->hasUnnamedAddr())
1772 Out
<< "unnamed_addr ";
1774 if (unsigned AddressSpace
= GV
->getType()->getAddressSpace())
1775 Out
<< "addrspace(" << AddressSpace
<< ") ";
1776 if (GV
->isExternallyInitialized()) Out
<< "externally_initialized ";
1777 Out
<< (GV
->isConstant() ? "constant " : "global ");
1778 TypePrinter
.print(GV
->getType()->getElementType(), Out
);
1780 if (GV
->hasInitializer()) {
1782 writeOperand(GV
->getInitializer(), false);
1785 if (GV
->hasSection()) {
1786 Out
<< ", section \"";
1787 PrintEscapedString(GV
->getSection(), Out
);
1790 maybePrintComdat(Out
, *GV
);
1791 if (GV
->getAlignment())
1792 Out
<< ", align " << GV
->getAlignment();
1794 printInfoComment(*GV
);
1797 void AssemblyWriter::printAlias(const GlobalAlias
*GA
) {
1798 if (GA
->isMaterializable())
1799 Out
<< "; Materializable\n";
1801 // Don't crash when dumping partially built GA
1803 Out
<< "<<nameless>> = ";
1805 PrintLLVMName(Out
, GA
);
1808 PrintLinkage(GA
->getLinkage(), Out
);
1809 PrintVisibility(GA
->getVisibility(), Out
);
1810 PrintDLLStorageClass(GA
->getDLLStorageClass(), Out
);
1811 PrintThreadLocalModel(GA
->getThreadLocalMode(), Out
);
1812 if (GA
->hasUnnamedAddr())
1813 Out
<< "unnamed_addr ";
1817 const Constant
*Aliasee
= GA
->getAliasee();
1820 TypePrinter
.print(GA
->getType(), Out
);
1821 Out
<< " <<NULL ALIASEE>>";
1823 writeOperand(Aliasee
, !isa
<ConstantExpr
>(Aliasee
));
1826 printInfoComment(*GA
);
1830 void AssemblyWriter::printComdat(const Comdat
*C
) {
1834 void AssemblyWriter::printTypeIdentities() {
1835 if (TypePrinter
.NumberedTypes
.empty() &&
1836 TypePrinter
.NamedTypes
.empty())
1841 // We know all the numbers that each type is used and we know that it is a
1842 // dense assignment. Convert the map to an index table.
1843 std::vector
<StructType
*> NumberedTypes(TypePrinter
.NumberedTypes
.size());
1844 for (DenseMap
<StructType
*, unsigned>::iterator I
=
1845 TypePrinter
.NumberedTypes
.begin(), E
= TypePrinter
.NumberedTypes
.end();
1847 assert(I
->second
< NumberedTypes
.size() && "Didn't get a dense numbering?");
1848 NumberedTypes
[I
->second
] = I
->first
;
1851 // Emit all numbered types.
1852 for (unsigned i
= 0, e
= NumberedTypes
.size(); i
!= e
; ++i
) {
1853 Out
<< '%' << i
<< " = type ";
1855 // Make sure we print out at least one level of the type structure, so
1856 // that we do not get %2 = type %2
1857 TypePrinter
.printStructBody(NumberedTypes
[i
], Out
);
1861 for (unsigned i
= 0, e
= TypePrinter
.NamedTypes
.size(); i
!= e
; ++i
) {
1862 PrintLLVMName(Out
, TypePrinter
.NamedTypes
[i
]->getName(), LocalPrefix
);
1865 // Make sure we print out at least one level of the type structure, so
1866 // that we do not get %FILE = type %FILE
1867 TypePrinter
.printStructBody(TypePrinter
.NamedTypes
[i
], Out
);
1872 /// printFunction - Print all aspects of a function.
1874 void AssemblyWriter::printFunction(const Function
*F
) {
1875 // Print out the return type and name.
1878 if (AnnotationWriter
) AnnotationWriter
->emitFunctionAnnot(F
, Out
);
1880 if (F
->isMaterializable())
1881 Out
<< "; Materializable\n";
1883 const AttributeSet
&Attrs
= F
->getAttributes();
1884 if (Attrs
.hasAttributes(AttributeSet::FunctionIndex
)) {
1885 AttributeSet AS
= Attrs
.getFnAttributes();
1886 std::string AttrStr
;
1889 for (unsigned E
= AS
.getNumSlots(); Idx
!= E
; ++Idx
)
1890 if (AS
.getSlotIndex(Idx
) == AttributeSet::FunctionIndex
)
1893 for (AttributeSet::iterator I
= AS
.begin(Idx
), E
= AS
.end(Idx
);
1895 Attribute Attr
= *I
;
1896 if (!Attr
.isStringAttribute()) {
1897 if (!AttrStr
.empty()) AttrStr
+= ' ';
1898 AttrStr
+= Attr
.getAsString();
1902 if (!AttrStr
.empty())
1903 Out
<< "; Function Attrs: " << AttrStr
<< '\n';
1906 if (F
->isDeclaration())
1911 PrintLinkage(F
->getLinkage(), Out
);
1912 PrintVisibility(F
->getVisibility(), Out
);
1913 PrintDLLStorageClass(F
->getDLLStorageClass(), Out
);
1915 // Print the calling convention.
1916 if (F
->getCallingConv() != CallingConv::C
) {
1917 PrintCallingConv(F
->getCallingConv(), Out
);
1921 FunctionType
*FT
= F
->getFunctionType();
1922 if (Attrs
.hasAttributes(AttributeSet::ReturnIndex
))
1923 Out
<< Attrs
.getAsString(AttributeSet::ReturnIndex
) << ' ';
1924 TypePrinter
.print(F
->getReturnType(), Out
);
1926 WriteAsOperandInternal(Out
, F
, &TypePrinter
, &Machine
, F
->getParent());
1928 Machine
.incorporateFunction(F
);
1930 // Loop over the arguments, printing them...
1933 if (!F
->isDeclaration()) {
1934 // If this isn't a declaration, print the argument names as well.
1935 for (Function::const_arg_iterator I
= F
->arg_begin(), E
= F
->arg_end();
1937 // Insert commas as we go... the first arg doesn't get a comma
1938 if (I
!= F
->arg_begin()) Out
<< ", ";
1939 printArgument(I
, Attrs
, Idx
);
1943 // Otherwise, print the types from the function type.
1944 for (unsigned i
= 0, e
= FT
->getNumParams(); i
!= e
; ++i
) {
1945 // Insert commas as we go... the first arg doesn't get a comma
1949 TypePrinter
.print(FT
->getParamType(i
), Out
);
1951 if (Attrs
.hasAttributes(i
+1))
1952 Out
<< ' ' << Attrs
.getAsString(i
+1);
1956 // Finish printing arguments...
1957 if (FT
->isVarArg()) {
1958 if (FT
->getNumParams()) Out
<< ", ";
1959 Out
<< "..."; // Output varargs portion of signature!
1962 if (F
->hasUnnamedAddr())
1963 Out
<< " unnamed_addr";
1964 if (Attrs
.hasAttributes(AttributeSet::FunctionIndex
))
1965 Out
<< " #" << Machine
.getAttributeGroupSlot(Attrs
.getFnAttributes());
1966 if (F
->hasSection()) {
1967 Out
<< " section \"";
1968 PrintEscapedString(F
->getSection(), Out
);
1971 maybePrintComdat(Out
, *F
);
1972 if (F
->getAlignment())
1973 Out
<< " align " << F
->getAlignment();
1975 Out
<< " gc \"" << F
->getGC() << '"';
1976 if (F
->hasPrefixData()) {
1978 writeOperand(F
->getPrefixData(), true);
1980 if (F
->hasPrologueData()) {
1981 Out
<< " prologue ";
1982 writeOperand(F
->getPrologueData(), true);
1985 if (F
->isDeclaration()) {
1989 // Output all of the function's basic blocks.
1990 for (Function::const_iterator I
= F
->begin(), E
= F
->end(); I
!= E
; ++I
)
1993 // Output the function's use-lists.
1999 Machine
.purgeFunction();
2002 /// printArgument - This member is called for every argument that is passed into
2003 /// the function. Simply print it out
2005 void AssemblyWriter::printArgument(const Argument
*Arg
,
2006 AttributeSet Attrs
, unsigned Idx
) {
2008 TypePrinter
.print(Arg
->getType(), Out
);
2010 // Output parameter attributes list
2011 if (Attrs
.hasAttributes(Idx
))
2012 Out
<< ' ' << Attrs
.getAsString(Idx
);
2014 // Output name, if available...
2015 if (Arg
->hasName()) {
2017 PrintLLVMName(Out
, Arg
);
2021 /// printBasicBlock - This member is called for each basic block in a method.
2023 void AssemblyWriter::printBasicBlock(const BasicBlock
*BB
) {
2024 if (BB
->hasName()) { // Print out the label if it exists...
2026 PrintLLVMName(Out
, BB
->getName(), LabelPrefix
);
2028 } else if (!BB
->use_empty()) { // Don't print block # of no uses...
2029 Out
<< "\n; <label>:";
2030 int Slot
= Machine
.getLocalSlot(BB
);
2037 if (!BB
->getParent()) {
2038 Out
.PadToColumn(50);
2039 Out
<< "; Error: Block without parent!";
2040 } else if (BB
!= &BB
->getParent()->getEntryBlock()) { // Not the entry block?
2041 // Output predecessors for the block.
2042 Out
.PadToColumn(50);
2044 const_pred_iterator PI
= pred_begin(BB
), PE
= pred_end(BB
);
2047 Out
<< " No predecessors!";
2050 writeOperand(*PI
, false);
2051 for (++PI
; PI
!= PE
; ++PI
) {
2053 writeOperand(*PI
, false);
2060 if (AnnotationWriter
) AnnotationWriter
->emitBasicBlockStartAnnot(BB
, Out
);
2062 // Output all of the instructions in the basic block...
2063 for (BasicBlock::const_iterator I
= BB
->begin(), E
= BB
->end(); I
!= E
; ++I
) {
2064 printInstructionLine(*I
);
2067 if (AnnotationWriter
) AnnotationWriter
->emitBasicBlockEndAnnot(BB
, Out
);
2070 /// printInstructionLine - Print an instruction and a newline character.
2071 void AssemblyWriter::printInstructionLine(const Instruction
&I
) {
2072 printInstruction(I
);
2076 /// printInfoComment - Print a little comment after the instruction indicating
2077 /// which slot it occupies.
2079 void AssemblyWriter::printInfoComment(const Value
&V
) {
2080 if (AnnotationWriter
)
2081 AnnotationWriter
->printInfoComment(V
, Out
);
2084 // This member is called for each Instruction in a function..
2085 void AssemblyWriter::printInstruction(const Instruction
&I
) {
2086 if (AnnotationWriter
) AnnotationWriter
->emitInstructionAnnot(&I
, Out
);
2088 // Print out indentation for an instruction.
2091 // Print out name if it exists...
2093 PrintLLVMName(Out
, &I
);
2095 } else if (!I
.getType()->isVoidTy()) {
2096 // Print out the def slot taken.
2097 int SlotNum
= Machine
.getLocalSlot(&I
);
2099 Out
<< "<badref> = ";
2101 Out
<< '%' << SlotNum
<< " = ";
2104 if (const CallInst
*CI
= dyn_cast
<CallInst
>(&I
)) {
2105 if (CI
->isMustTailCall())
2107 else if (CI
->isTailCall())
2111 // Print out the opcode...
2112 Out
<< I
.getOpcodeName();
2114 // If this is an atomic load or store, print out the atomic marker.
2115 if ((isa
<LoadInst
>(I
) && cast
<LoadInst
>(I
).isAtomic()) ||
2116 (isa
<StoreInst
>(I
) && cast
<StoreInst
>(I
).isAtomic()))
2119 if (isa
<AtomicCmpXchgInst
>(I
) && cast
<AtomicCmpXchgInst
>(I
).isWeak())
2122 // If this is a volatile operation, print out the volatile marker.
2123 if ((isa
<LoadInst
>(I
) && cast
<LoadInst
>(I
).isVolatile()) ||
2124 (isa
<StoreInst
>(I
) && cast
<StoreInst
>(I
).isVolatile()) ||
2125 (isa
<AtomicCmpXchgInst
>(I
) && cast
<AtomicCmpXchgInst
>(I
).isVolatile()) ||
2126 (isa
<AtomicRMWInst
>(I
) && cast
<AtomicRMWInst
>(I
).isVolatile()))
2129 // Print out optimization information.
2130 WriteOptimizationInfo(Out
, &I
);
2132 // Print out the compare instruction predicates
2133 if (const CmpInst
*CI
= dyn_cast
<CmpInst
>(&I
))
2134 Out
<< ' ' << getPredicateText(CI
->getPredicate());
2136 // Print out the atomicrmw operation
2137 if (const AtomicRMWInst
*RMWI
= dyn_cast
<AtomicRMWInst
>(&I
))
2138 writeAtomicRMWOperation(Out
, RMWI
->getOperation());
2140 // Print out the type of the operands...
2141 const Value
*Operand
= I
.getNumOperands() ? I
.getOperand(0) : nullptr;
2143 // Special case conditional branches to swizzle the condition out to the front
2144 if (isa
<BranchInst
>(I
) && cast
<BranchInst
>(I
).isConditional()) {
2145 const BranchInst
&BI(cast
<BranchInst
>(I
));
2147 writeOperand(BI
.getCondition(), true);
2149 writeOperand(BI
.getSuccessor(0), true);
2151 writeOperand(BI
.getSuccessor(1), true);
2153 } else if (isa
<SwitchInst
>(I
)) {
2154 const SwitchInst
& SI(cast
<SwitchInst
>(I
));
2155 // Special case switch instruction to get formatting nice and correct.
2157 writeOperand(SI
.getCondition(), true);
2159 writeOperand(SI
.getDefaultDest(), true);
2161 for (SwitchInst::ConstCaseIt i
= SI
.case_begin(), e
= SI
.case_end();
2164 writeOperand(i
.getCaseValue(), true);
2166 writeOperand(i
.getCaseSuccessor(), true);
2169 } else if (isa
<IndirectBrInst
>(I
)) {
2170 // Special case indirectbr instruction to get formatting nice and correct.
2172 writeOperand(Operand
, true);
2175 for (unsigned i
= 1, e
= I
.getNumOperands(); i
!= e
; ++i
) {
2178 writeOperand(I
.getOperand(i
), true);
2181 } else if (const PHINode
*PN
= dyn_cast
<PHINode
>(&I
)) {
2183 TypePrinter
.print(I
.getType(), Out
);
2186 for (unsigned op
= 0, Eop
= PN
->getNumIncomingValues(); op
< Eop
; ++op
) {
2187 if (op
) Out
<< ", ";
2189 writeOperand(PN
->getIncomingValue(op
), false); Out
<< ", ";
2190 writeOperand(PN
->getIncomingBlock(op
), false); Out
<< " ]";
2192 } else if (const ExtractValueInst
*EVI
= dyn_cast
<ExtractValueInst
>(&I
)) {
2194 writeOperand(I
.getOperand(0), true);
2195 for (const unsigned *i
= EVI
->idx_begin(), *e
= EVI
->idx_end(); i
!= e
; ++i
)
2197 } else if (const InsertValueInst
*IVI
= dyn_cast
<InsertValueInst
>(&I
)) {
2199 writeOperand(I
.getOperand(0), true); Out
<< ", ";
2200 writeOperand(I
.getOperand(1), true);
2201 for (const unsigned *i
= IVI
->idx_begin(), *e
= IVI
->idx_end(); i
!= e
; ++i
)
2203 } else if (const LandingPadInst
*LPI
= dyn_cast
<LandingPadInst
>(&I
)) {
2205 TypePrinter
.print(I
.getType(), Out
);
2206 Out
<< " personality ";
2207 writeOperand(I
.getOperand(0), true); Out
<< '\n';
2209 if (LPI
->isCleanup())
2212 for (unsigned i
= 0, e
= LPI
->getNumClauses(); i
!= e
; ++i
) {
2213 if (i
!= 0 || LPI
->isCleanup()) Out
<< "\n";
2214 if (LPI
->isCatch(i
))
2219 writeOperand(LPI
->getClause(i
), true);
2221 } else if (isa
<ReturnInst
>(I
) && !Operand
) {
2223 } else if (const CallInst
*CI
= dyn_cast
<CallInst
>(&I
)) {
2224 // Print the calling convention being used.
2225 if (CI
->getCallingConv() != CallingConv::C
) {
2227 PrintCallingConv(CI
->getCallingConv(), Out
);
2230 Operand
= CI
->getCalledValue();
2231 PointerType
*PTy
= cast
<PointerType
>(Operand
->getType());
2232 FunctionType
*FTy
= cast
<FunctionType
>(PTy
->getElementType());
2233 Type
*RetTy
= FTy
->getReturnType();
2234 const AttributeSet
&PAL
= CI
->getAttributes();
2236 if (PAL
.hasAttributes(AttributeSet::ReturnIndex
))
2237 Out
<< ' ' << PAL
.getAsString(AttributeSet::ReturnIndex
);
2239 // If possible, print out the short form of the call instruction. We can
2240 // only do this if the first argument is a pointer to a nonvararg function,
2241 // and if the return type is not a pointer to a function.
2244 if (!FTy
->isVarArg() &&
2245 (!RetTy
->isPointerTy() ||
2246 !cast
<PointerType
>(RetTy
)->getElementType()->isFunctionTy())) {
2247 TypePrinter
.print(RetTy
, Out
);
2249 writeOperand(Operand
, false);
2251 writeOperand(Operand
, true);
2254 for (unsigned op
= 0, Eop
= CI
->getNumArgOperands(); op
< Eop
; ++op
) {
2257 writeParamOperand(CI
->getArgOperand(op
), PAL
, op
+ 1);
2260 // Emit an ellipsis if this is a musttail call in a vararg function. This
2261 // is only to aid readability, musttail calls forward varargs by default.
2262 if (CI
->isMustTailCall() && CI
->getParent() &&
2263 CI
->getParent()->getParent() &&
2264 CI
->getParent()->getParent()->isVarArg())
2268 if (PAL
.hasAttributes(AttributeSet::FunctionIndex
))
2269 Out
<< " #" << Machine
.getAttributeGroupSlot(PAL
.getFnAttributes());
2270 } else if (const InvokeInst
*II
= dyn_cast
<InvokeInst
>(&I
)) {
2271 Operand
= II
->getCalledValue();
2272 PointerType
*PTy
= cast
<PointerType
>(Operand
->getType());
2273 FunctionType
*FTy
= cast
<FunctionType
>(PTy
->getElementType());
2274 Type
*RetTy
= FTy
->getReturnType();
2275 const AttributeSet
&PAL
= II
->getAttributes();
2277 // Print the calling convention being used.
2278 if (II
->getCallingConv() != CallingConv::C
) {
2280 PrintCallingConv(II
->getCallingConv(), Out
);
2283 if (PAL
.hasAttributes(AttributeSet::ReturnIndex
))
2284 Out
<< ' ' << PAL
.getAsString(AttributeSet::ReturnIndex
);
2286 // If possible, print out the short form of the invoke instruction. We can
2287 // only do this if the first argument is a pointer to a nonvararg function,
2288 // and if the return type is not a pointer to a function.
2291 if (!FTy
->isVarArg() &&
2292 (!RetTy
->isPointerTy() ||
2293 !cast
<PointerType
>(RetTy
)->getElementType()->isFunctionTy())) {
2294 TypePrinter
.print(RetTy
, Out
);
2296 writeOperand(Operand
, false);
2298 writeOperand(Operand
, true);
2301 for (unsigned op
= 0, Eop
= II
->getNumArgOperands(); op
< Eop
; ++op
) {
2304 writeParamOperand(II
->getArgOperand(op
), PAL
, op
+ 1);
2308 if (PAL
.hasAttributes(AttributeSet::FunctionIndex
))
2309 Out
<< " #" << Machine
.getAttributeGroupSlot(PAL
.getFnAttributes());
2312 writeOperand(II
->getNormalDest(), true);
2314 writeOperand(II
->getUnwindDest(), true);
2316 } else if (const AllocaInst
*AI
= dyn_cast
<AllocaInst
>(&I
)) {
2318 if (AI
->isUsedWithInAlloca())
2320 TypePrinter
.print(AI
->getAllocatedType(), Out
);
2321 if (!AI
->getArraySize() || AI
->isArrayAllocation()) {
2323 writeOperand(AI
->getArraySize(), true);
2325 if (AI
->getAlignment()) {
2326 Out
<< ", align " << AI
->getAlignment();
2328 } else if (isa
<CastInst
>(I
)) {
2331 writeOperand(Operand
, true); // Work with broken code
2334 TypePrinter
.print(I
.getType(), Out
);
2335 } else if (isa
<VAArgInst
>(I
)) {
2338 writeOperand(Operand
, true); // Work with broken code
2341 TypePrinter
.print(I
.getType(), Out
);
2342 } else if (Operand
) { // Print the normal way.
2344 // PrintAllTypes - Instructions who have operands of all the same type
2345 // omit the type from all but the first operand. If the instruction has
2346 // different type operands (for example br), then they are all printed.
2347 bool PrintAllTypes
= false;
2348 Type
*TheType
= Operand
->getType();
2350 // Select, Store and ShuffleVector always print all types.
2351 if (isa
<SelectInst
>(I
) || isa
<StoreInst
>(I
) || isa
<ShuffleVectorInst
>(I
)
2352 || isa
<ReturnInst
>(I
)) {
2353 PrintAllTypes
= true;
2355 for (unsigned i
= 1, E
= I
.getNumOperands(); i
!= E
; ++i
) {
2356 Operand
= I
.getOperand(i
);
2357 // note that Operand shouldn't be null, but the test helps make dump()
2358 // more tolerant of malformed IR
2359 if (Operand
&& Operand
->getType() != TheType
) {
2360 PrintAllTypes
= true; // We have differing types! Print them all!
2366 if (!PrintAllTypes
) {
2368 TypePrinter
.print(TheType
, Out
);
2372 for (unsigned i
= 0, E
= I
.getNumOperands(); i
!= E
; ++i
) {
2374 writeOperand(I
.getOperand(i
), PrintAllTypes
);
2378 // Print atomic ordering/alignment for memory operations
2379 if (const LoadInst
*LI
= dyn_cast
<LoadInst
>(&I
)) {
2381 writeAtomic(LI
->getOrdering(), LI
->getSynchScope());
2382 if (LI
->getAlignment())
2383 Out
<< ", align " << LI
->getAlignment();
2384 } else if (const StoreInst
*SI
= dyn_cast
<StoreInst
>(&I
)) {
2386 writeAtomic(SI
->getOrdering(), SI
->getSynchScope());
2387 if (SI
->getAlignment())
2388 Out
<< ", align " << SI
->getAlignment();
2389 } else if (const AtomicCmpXchgInst
*CXI
= dyn_cast
<AtomicCmpXchgInst
>(&I
)) {
2390 writeAtomicCmpXchg(CXI
->getSuccessOrdering(), CXI
->getFailureOrdering(),
2391 CXI
->getSynchScope());
2392 } else if (const AtomicRMWInst
*RMWI
= dyn_cast
<AtomicRMWInst
>(&I
)) {
2393 writeAtomic(RMWI
->getOrdering(), RMWI
->getSynchScope());
2394 } else if (const FenceInst
*FI
= dyn_cast
<FenceInst
>(&I
)) {
2395 writeAtomic(FI
->getOrdering(), FI
->getSynchScope());
2398 // Print Metadata info.
2399 SmallVector
<std::pair
<unsigned, MDNode
*>, 4> InstMD
;
2400 I
.getAllMetadata(InstMD
);
2401 if (!InstMD
.empty()) {
2402 SmallVector
<StringRef
, 8> MDNames
;
2403 I
.getType()->getContext().getMDKindNames(MDNames
);
2404 for (unsigned i
= 0, e
= InstMD
.size(); i
!= e
; ++i
) {
2405 unsigned Kind
= InstMD
[i
].first
;
2406 if (Kind
< MDNames
.size()) {
2407 Out
<< ", !" << MDNames
[Kind
];
2409 Out
<< ", !<unknown kind #" << Kind
<< ">";
2412 WriteAsOperandInternal(Out
, InstMD
[i
].second
, &TypePrinter
, &Machine
,
2416 printInfoComment(I
);
2419 static void WriteMDNodeComment(const MDNode
*Node
,
2420 formatted_raw_ostream
&Out
) {
2421 if (Node
->getNumOperands() < 1)
2424 Metadata
*Op
= Node
->getOperand(0);
2425 if (!Op
|| !isa
<MDString
>(Op
))
2428 DIDescriptor
Desc(Node
);
2432 unsigned Tag
= Desc
.getTag();
2433 Out
.PadToColumn(50);
2434 if (dwarf::TagString(Tag
)) {
2437 } else if (Tag
== dwarf::DW_TAG_user_base
) {
2438 Out
<< "; [ DW_TAG_user_base ]";
2442 void AssemblyWriter::writeMDNode(unsigned Slot
, const MDNode
*Node
) {
2443 Out
<< '!' << Slot
<< " = ";
2444 printMDNodeBody(Node
);
2447 void AssemblyWriter::writeAllMDNodes() {
2448 SmallVector
<const MDNode
*, 16> Nodes
;
2449 Nodes
.resize(Machine
.mdn_size());
2450 for (SlotTracker::mdn_iterator I
= Machine
.mdn_begin(), E
= Machine
.mdn_end();
2452 Nodes
[I
->second
] = cast
<MDNode
>(I
->first
);
2454 for (unsigned i
= 0, e
= Nodes
.size(); i
!= e
; ++i
) {
2455 writeMDNode(i
, Nodes
[i
]);
2459 void AssemblyWriter::printMDNodeBody(const MDNode
*Node
) {
2460 WriteMDNodeBodyInternal(Out
, Node
, &TypePrinter
, &Machine
, TheModule
);
2461 WriteMDNodeComment(Node
, Out
);
2465 void AssemblyWriter::writeAllAttributeGroups() {
2466 std::vector
<std::pair
<AttributeSet
, unsigned> > asVec
;
2467 asVec
.resize(Machine
.as_size());
2469 for (SlotTracker::as_iterator I
= Machine
.as_begin(), E
= Machine
.as_end();
2471 asVec
[I
->second
] = *I
;
2473 for (std::vector
<std::pair
<AttributeSet
, unsigned> >::iterator
2474 I
= asVec
.begin(), E
= asVec
.end(); I
!= E
; ++I
)
2475 Out
<< "attributes #" << I
->second
<< " = { "
2476 << I
->first
.getAsString(AttributeSet::FunctionIndex
, true) << " }\n";
2481 void AssemblyWriter::printUseListOrder(const UseListOrder
&Order
) {
2482 bool IsInFunction
= Machine
.getFunction();
2486 Out
<< "uselistorder";
2487 if (const BasicBlock
*BB
=
2488 IsInFunction
? nullptr : dyn_cast
<BasicBlock
>(Order
.V
)) {
2490 writeOperand(BB
->getParent(), false);
2492 writeOperand(BB
, false);
2495 writeOperand(Order
.V
, true);
2499 assert(Order
.Shuffle
.size() >= 2 && "Shuffle too small");
2500 Out
<< Order
.Shuffle
[0];
2501 for (unsigned I
= 1, E
= Order
.Shuffle
.size(); I
!= E
; ++I
)
2502 Out
<< ", " << Order
.Shuffle
[I
];
2506 void AssemblyWriter::printUseLists(const Function
*F
) {
2508 [&]() { return !UseListOrders
.empty() && UseListOrders
.back().F
== F
; };
2513 Out
<< "\n; uselistorder directives\n";
2515 printUseListOrder(UseListOrders
.back());
2516 UseListOrders
.pop_back();
2520 //===----------------------------------------------------------------------===//
2521 // External Interface declarations
2522 //===----------------------------------------------------------------------===//
2524 void Module::print(raw_ostream
&ROS
, AssemblyAnnotationWriter
*AAW
) const {
2525 SlotTracker
SlotTable(this);
2526 formatted_raw_ostream
OS(ROS
);
2527 AssemblyWriter
W(OS
, SlotTable
, this, AAW
);
2528 W
.printModule(this);
2531 void NamedMDNode::print(raw_ostream
&ROS
) const {
2532 SlotTracker
SlotTable(getParent());
2533 formatted_raw_ostream
OS(ROS
);
2534 AssemblyWriter
W(OS
, SlotTable
, getParent(), nullptr);
2535 W
.printNamedMDNode(this);
2538 void Comdat::print(raw_ostream
&ROS
) const {
2539 PrintLLVMName(ROS
, getName(), ComdatPrefix
);
2540 ROS
<< " = comdat ";
2542 switch (getSelectionKind()) {
2546 case Comdat::ExactMatch
:
2547 ROS
<< "exactmatch";
2549 case Comdat::Largest
:
2552 case Comdat::NoDuplicates
:
2553 ROS
<< "noduplicates";
2555 case Comdat::SameSize
:
2563 void Type::print(raw_ostream
&OS
) const {
2565 TP
.print(const_cast<Type
*>(this), OS
);
2567 // If the type is a named struct type, print the body as well.
2568 if (StructType
*STy
= dyn_cast
<StructType
>(const_cast<Type
*>(this)))
2569 if (!STy
->isLiteral()) {
2571 TP
.printStructBody(STy
, OS
);
2575 void Value::print(raw_ostream
&ROS
) const {
2576 formatted_raw_ostream
OS(ROS
);
2577 if (const Instruction
*I
= dyn_cast
<Instruction
>(this)) {
2578 const Function
*F
= I
->getParent() ? I
->getParent()->getParent() : nullptr;
2579 SlotTracker
SlotTable(F
);
2580 AssemblyWriter
W(OS
, SlotTable
, getModuleFromVal(I
), nullptr);
2581 W
.printInstruction(*I
);
2582 } else if (const BasicBlock
*BB
= dyn_cast
<BasicBlock
>(this)) {
2583 SlotTracker
SlotTable(BB
->getParent());
2584 AssemblyWriter
W(OS
, SlotTable
, getModuleFromVal(BB
), nullptr);
2585 W
.printBasicBlock(BB
);
2586 } else if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(this)) {
2587 SlotTracker
SlotTable(GV
->getParent());
2588 AssemblyWriter
W(OS
, SlotTable
, GV
->getParent(), nullptr);
2589 if (const GlobalVariable
*V
= dyn_cast
<GlobalVariable
>(GV
))
2591 else if (const Function
*F
= dyn_cast
<Function
>(GV
))
2594 W
.printAlias(cast
<GlobalAlias
>(GV
));
2595 } else if (const MetadataAsValue
*V
= dyn_cast
<MetadataAsValue
>(this)) {
2596 V
->getMetadata()->print(ROS
);
2597 } else if (const Constant
*C
= dyn_cast
<Constant
>(this)) {
2598 TypePrinting TypePrinter
;
2599 TypePrinter
.print(C
->getType(), OS
);
2601 WriteConstantInternal(OS
, C
, TypePrinter
, nullptr, nullptr);
2602 } else if (isa
<InlineAsm
>(this) || isa
<Argument
>(this)) {
2603 this->printAsOperand(OS
);
2605 llvm_unreachable("Unknown value to print out!");
2609 void Value::printAsOperand(raw_ostream
&O
, bool PrintType
, const Module
*M
) const {
2610 // Fast path: Don't construct and populate a TypePrinting object if we
2611 // won't be needing any types printed.
2612 if (!PrintType
&& ((!isa
<Constant
>(this) && !isa
<MetadataAsValue
>(this)) ||
2613 hasName() || isa
<GlobalValue
>(this))) {
2614 WriteAsOperandInternal(O
, this, nullptr, nullptr, M
);
2619 M
= getModuleFromVal(this);
2621 TypePrinting TypePrinter
;
2623 TypePrinter
.incorporateTypes(*M
);
2625 TypePrinter
.print(getType(), O
);
2629 WriteAsOperandInternal(O
, this, &TypePrinter
, nullptr, M
);
2632 void Metadata::print(raw_ostream
&ROS
) const {
2633 formatted_raw_ostream
OS(ROS
);
2634 if (auto *N
= dyn_cast
<MDNode
>(this)) {
2635 SlotTracker
SlotTable(static_cast<Function
*>(nullptr));
2636 AssemblyWriter
W(OS
, SlotTable
, nullptr, nullptr);
2637 W
.printMDNodeBody(N
);
2644 void Metadata::printAsOperand(raw_ostream
&ROS
, bool PrintType
,
2645 const Module
*M
) const {
2646 formatted_raw_ostream
OS(ROS
);
2648 std::unique_ptr
<TypePrinting
> TypePrinter
;
2650 TypePrinter
.reset(new TypePrinting
);
2652 TypePrinter
->incorporateTypes(*M
);
2654 WriteAsOperandInternal(OS
, this, TypePrinter
.get(), nullptr, M
,
2655 /* FromValue */ true);
2658 // Value::dump - allow easy printing of Values from the debugger.
2659 void Value::dump() const { print(dbgs()); dbgs() << '\n'; }
2661 // Type::dump - allow easy printing of Types from the debugger.
2662 void Type::dump() const { print(dbgs()); dbgs() << '\n'; }
2664 // Module::dump() - Allow printing of Modules from the debugger.
2665 void Module::dump() const { print(dbgs(), nullptr); }
2667 // \brief Allow printing of Comdats from the debugger.
2668 void Comdat::dump() const { print(dbgs()); }
2670 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
2671 void NamedMDNode::dump() const { print(dbgs()); }
2673 void Metadata::dump() const {