1 //===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===//
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 file implements the AsmPrinter class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/CodeGen/AsmPrinter.h"
15 #include "llvm/Assembly/Writer.h"
16 #include "llvm/DerivedTypes.h"
17 #include "llvm/Constants.h"
18 #include "llvm/Module.h"
19 #include "llvm/CodeGen/GCMetadataPrinter.h"
20 #include "llvm/CodeGen/MachineConstantPool.h"
21 #include "llvm/CodeGen/MachineJumpTableInfo.h"
22 #include "llvm/CodeGen/MachineLoopInfo.h"
23 #include "llvm/CodeGen/MachineModuleInfo.h"
24 #include "llvm/CodeGen/DwarfWriter.h"
25 #include "llvm/Analysis/DebugInfo.h"
26 #include "llvm/MC/MCContext.h"
27 #include "llvm/MC/MCInst.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCStreamer.h"
30 #include "llvm/Support/CommandLine.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/FormattedStream.h"
33 #include "llvm/Support/IOManip.h"
34 #include "llvm/Support/Mangler.h"
35 #include "llvm/Target/TargetAsmInfo.h"
36 #include "llvm/Target/TargetData.h"
37 #include "llvm/Target/TargetLowering.h"
38 #include "llvm/Target/TargetLoweringObjectFile.h"
39 #include "llvm/Target/TargetOptions.h"
40 #include "llvm/Target/TargetRegisterInfo.h"
41 #include "llvm/ADT/SmallPtrSet.h"
42 #include "llvm/ADT/SmallString.h"
43 #include "llvm/ADT/StringExtras.h"
47 static cl::opt
<cl::boolOrDefault
>
48 AsmVerbose("asm-verbose", cl::desc("Add comments to directives."),
49 cl::init(cl::BOU_UNSET
));
51 static cl::opt
<cl::boolOrDefault
>
52 AsmExuberant("asm-exuberant", cl::desc("Add many comments."),
53 cl::init(cl::BOU_FALSE
));
55 char AsmPrinter::ID
= 0;
56 AsmPrinter::AsmPrinter(formatted_raw_ostream
&o
, TargetMachine
&tm
,
57 const TargetAsmInfo
*T
, bool VDef
)
58 : MachineFunctionPass(&ID
), FunctionNumber(0), O(o
),
59 TM(tm
), TAI(T
), TRI(tm
.getRegisterInfo()),
61 OutContext(*new MCContext()),
62 OutStreamer(*createAsmStreamer(OutContext
, O
)),
64 LastMI(0), LastFn(0), Counter(~0U),
65 PrevDLT(0, ~0U, ~0U) {
69 case cl::BOU_UNSET
: VerboseAsm
= VDef
; break;
70 case cl::BOU_TRUE
: VerboseAsm
= true; break;
71 case cl::BOU_FALSE
: VerboseAsm
= false; break;
73 switch (AsmExuberant
) {
74 case cl::BOU_UNSET
: ExuberantAsm
= false; break;
75 case cl::BOU_TRUE
: ExuberantAsm
= true; break;
76 case cl::BOU_FALSE
: ExuberantAsm
= false; break;
80 AsmPrinter::~AsmPrinter() {
81 for (gcp_iterator I
= GCMetadataPrinters
.begin(),
82 E
= GCMetadataPrinters
.end(); I
!= E
; ++I
)
89 TargetLoweringObjectFile
&AsmPrinter::getObjFileLowering() const {
90 return TM
.getTargetLowering()->getObjFileLowering();
93 /// SwitchToSection - Switch to the specified section of the executable if we
94 /// are not already in it! If "NS" is null, then this causes us to exit the
95 /// current section and not reenter another one. This is generally used for
98 /// FIXME: Remove support for null sections.
100 void AsmPrinter::SwitchToSection(const MCSection
*NS
) {
101 // If we're already in this section, we're done.
102 if (CurrentSection
== NS
) return;
108 NS
->PrintSwitchToSection(*TAI
, O
);
111 void AsmPrinter::getAnalysisUsage(AnalysisUsage
&AU
) const {
112 AU
.setPreservesAll();
113 MachineFunctionPass::getAnalysisUsage(AU
);
114 AU
.addRequired
<GCModuleInfo
>();
116 AU
.addRequired
<MachineLoopInfo
>();
120 bool AsmPrinter::doInitialization(Module
&M
) {
121 // Initialize TargetLoweringObjectFile.
122 const_cast<TargetLoweringObjectFile
&>(getObjFileLowering())
123 .Initialize(OutContext
, TM
);
125 Mang
= new Mangler(M
, TAI
->getGlobalPrefix(), TAI
->getPrivateGlobalPrefix(),
126 TAI
->getLinkerPrivateGlobalPrefix());
128 if (TAI
->doesAllowQuotesInName())
129 Mang
->setUseQuotes(true);
131 GCModuleInfo
*MI
= getAnalysisIfAvailable
<GCModuleInfo
>();
132 assert(MI
&& "AsmPrinter didn't require GCModuleInfo?");
134 if (TAI
->hasSingleParameterDotFile()) {
135 /* Very minimal debug info. It is ignored if we emit actual
136 debug info. If we don't, this at helps the user find where
137 a function came from. */
138 O
<< "\t.file\t\"" << M
.getModuleIdentifier() << "\"\n";
141 for (GCModuleInfo::iterator I
= MI
->begin(), E
= MI
->end(); I
!= E
; ++I
)
142 if (GCMetadataPrinter
*MP
= GetOrCreateGCPrinter(*I
))
143 MP
->beginAssembly(O
, *this, *TAI
);
145 if (!M
.getModuleInlineAsm().empty())
146 O
<< TAI
->getCommentString() << " Start of file scope inline assembly\n"
147 << M
.getModuleInlineAsm()
148 << '\n' << TAI
->getCommentString()
149 << " End of file scope inline assembly\n";
151 SwitchToSection(0); // Reset back to no section to close off sections.
153 if (TAI
->doesSupportDebugInformation() ||
154 TAI
->doesSupportExceptionHandling()) {
155 MMI
= getAnalysisIfAvailable
<MachineModuleInfo
>();
157 MMI
->AnalyzeModule(M
);
158 DW
= getAnalysisIfAvailable
<DwarfWriter
>();
160 DW
->BeginModule(&M
, MMI
, O
, this, TAI
);
166 bool AsmPrinter::doFinalization(Module
&M
) {
167 // Emit global variables.
168 for (Module::const_global_iterator I
= M
.global_begin(), E
= M
.global_end();
170 PrintGlobalVariable(I
);
172 // Emit final debug information.
173 if (TAI
->doesSupportDebugInformation() || TAI
->doesSupportExceptionHandling())
176 // If the target wants to know about weak references, print them all.
177 if (TAI
->getWeakRefDirective()) {
178 // FIXME: This is not lazy, it would be nice to only print weak references
179 // to stuff that is actually used. Note that doing so would require targets
180 // to notice uses in operands (due to constant exprs etc). This should
181 // happen with the MC stuff eventually.
184 // Print out module-level global variables here.
185 for (Module::const_global_iterator I
= M
.global_begin(), E
= M
.global_end();
187 if (I
->hasExternalWeakLinkage())
188 O
<< TAI
->getWeakRefDirective() << Mang
->getMangledName(I
) << '\n';
191 for (Module::const_iterator I
= M
.begin(), E
= M
.end(); I
!= E
; ++I
) {
192 if (I
->hasExternalWeakLinkage())
193 O
<< TAI
->getWeakRefDirective() << Mang
->getMangledName(I
) << '\n';
197 if (TAI
->getSetDirective()) {
199 for (Module::const_alias_iterator I
= M
.alias_begin(), E
= M
.alias_end();
201 std::string Name
= Mang
->getMangledName(I
);
203 const GlobalValue
*GV
= cast
<GlobalValue
>(I
->getAliasedGlobal());
204 std::string Target
= Mang
->getMangledName(GV
);
206 if (I
->hasExternalLinkage() || !TAI
->getWeakRefDirective())
207 O
<< "\t.globl\t" << Name
<< '\n';
208 else if (I
->hasWeakLinkage())
209 O
<< TAI
->getWeakRefDirective() << Name
<< '\n';
210 else if (!I
->hasLocalLinkage())
211 llvm_unreachable("Invalid alias linkage");
213 printVisibility(Name
, I
->getVisibility());
215 O
<< TAI
->getSetDirective() << ' ' << Name
<< ", " << Target
<< '\n';
219 GCModuleInfo
*MI
= getAnalysisIfAvailable
<GCModuleInfo
>();
220 assert(MI
&& "AsmPrinter didn't require GCModuleInfo?");
221 for (GCModuleInfo::iterator I
= MI
->end(), E
= MI
->begin(); I
!= E
; )
222 if (GCMetadataPrinter
*MP
= GetOrCreateGCPrinter(*--I
))
223 MP
->finishAssembly(O
, *this, *TAI
);
225 // If we don't have any trampolines, then we don't require stack memory
226 // to be executable. Some targets have a directive to declare this.
227 Function
*InitTrampolineIntrinsic
= M
.getFunction("llvm.init.trampoline");
228 if (!InitTrampolineIntrinsic
|| InitTrampolineIntrinsic
->use_empty())
229 if (TAI
->getNonexecutableStackDirective())
230 O
<< TAI
->getNonexecutableStackDirective() << '\n';
232 delete Mang
; Mang
= 0;
235 OutStreamer
.Finish();
240 AsmPrinter::getCurrentFunctionEHName(const MachineFunction
*MF
) const {
241 assert(MF
&& "No machine function?");
242 return Mang
->getMangledName(MF
->getFunction(), ".eh",
243 TAI
->is_EHSymbolPrivate());
246 void AsmPrinter::SetupMachineFunction(MachineFunction
&MF
) {
247 // What's my mangled name?
248 CurrentFnName
= Mang
->getMangledName(MF
.getFunction());
249 IncrementFunctionNumber();
252 LI
= &getAnalysis
<MachineLoopInfo
>();
257 // SectionCPs - Keep track the alignment, constpool entries per Section.
261 SmallVector
<unsigned, 4> CPEs
;
262 SectionCPs(const MCSection
*s
, unsigned a
) : S(s
), Alignment(a
) {};
266 /// EmitConstantPool - Print to the current output stream assembly
267 /// representations of the constants in the constant pool MCP. This is
268 /// used to print out constants which have been "spilled to memory" by
269 /// the code generator.
271 void AsmPrinter::EmitConstantPool(MachineConstantPool
*MCP
) {
272 const std::vector
<MachineConstantPoolEntry
> &CP
= MCP
->getConstants();
273 if (CP
.empty()) return;
275 // Calculate sections for constant pool entries. We collect entries to go into
276 // the same section together to reduce amount of section switch statements.
277 SmallVector
<SectionCPs
, 4> CPSections
;
278 for (unsigned i
= 0, e
= CP
.size(); i
!= e
; ++i
) {
279 const MachineConstantPoolEntry
&CPE
= CP
[i
];
280 unsigned Align
= CPE
.getAlignment();
283 switch (CPE
.getRelocationInfo()) {
284 default: llvm_unreachable("Unknown section kind");
285 case 2: Kind
= SectionKind::getReadOnlyWithRel(); break;
287 Kind
= SectionKind::getReadOnlyWithRelLocal();
290 switch (TM
.getTargetData()->getTypeAllocSize(CPE
.getType())) {
291 case 4: Kind
= SectionKind::getMergeableConst4(); break;
292 case 8: Kind
= SectionKind::getMergeableConst8(); break;
293 case 16: Kind
= SectionKind::getMergeableConst16();break;
294 default: Kind
= SectionKind::getMergeableConst(); break;
298 const MCSection
*S
= getObjFileLowering().getSectionForConstant(Kind
);
300 // The number of sections are small, just do a linear search from the
301 // last section to the first.
303 unsigned SecIdx
= CPSections
.size();
304 while (SecIdx
!= 0) {
305 if (CPSections
[--SecIdx
].S
== S
) {
311 SecIdx
= CPSections
.size();
312 CPSections
.push_back(SectionCPs(S
, Align
));
315 if (Align
> CPSections
[SecIdx
].Alignment
)
316 CPSections
[SecIdx
].Alignment
= Align
;
317 CPSections
[SecIdx
].CPEs
.push_back(i
);
320 // Now print stuff into the calculated sections.
321 for (unsigned i
= 0, e
= CPSections
.size(); i
!= e
; ++i
) {
322 SwitchToSection(CPSections
[i
].S
);
323 EmitAlignment(Log2_32(CPSections
[i
].Alignment
));
326 for (unsigned j
= 0, ee
= CPSections
[i
].CPEs
.size(); j
!= ee
; ++j
) {
327 unsigned CPI
= CPSections
[i
].CPEs
[j
];
328 MachineConstantPoolEntry CPE
= CP
[CPI
];
330 // Emit inter-object padding for alignment.
331 unsigned AlignMask
= CPE
.getAlignment() - 1;
332 unsigned NewOffset
= (Offset
+ AlignMask
) & ~AlignMask
;
333 EmitZeros(NewOffset
- Offset
);
335 const Type
*Ty
= CPE
.getType();
336 Offset
= NewOffset
+ TM
.getTargetData()->getTypeAllocSize(Ty
);
338 O
<< TAI
->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
341 O
.PadToColumn(TAI
->getCommentColumn(), 1);
342 O
<< TAI
->getCommentString() << " constant ";
343 WriteTypeSymbolic(O
, CPE
.getType(), MF
->getFunction()->getParent());
346 if (CPE
.isMachineConstantPoolEntry())
347 EmitMachineConstantPoolValue(CPE
.Val
.MachineCPVal
);
349 EmitGlobalConstant(CPE
.Val
.ConstVal
);
354 /// EmitJumpTableInfo - Print assembly representations of the jump tables used
355 /// by the current function to the current output stream.
357 void AsmPrinter::EmitJumpTableInfo(MachineJumpTableInfo
*MJTI
,
358 MachineFunction
&MF
) {
359 const std::vector
<MachineJumpTableEntry
> &JT
= MJTI
->getJumpTables();
360 if (JT
.empty()) return;
362 bool IsPic
= TM
.getRelocationModel() == Reloc::PIC_
;
364 // Pick the directive to use to print the jump table entries, and switch to
365 // the appropriate section.
366 TargetLowering
*LoweringInfo
= TM
.getTargetLowering();
368 const Function
*F
= MF
.getFunction();
369 bool JTInDiffSection
= false;
370 if (F
->isWeakForLinker() ||
371 (IsPic
&& !LoweringInfo
->usesGlobalOffsetTable())) {
372 // In PIC mode, we need to emit the jump table to the same section as the
373 // function body itself, otherwise the label differences won't make sense.
374 // We should also do if the section name is NULL or function is declared in
375 // discardable section.
376 SwitchToSection(getObjFileLowering().SectionForGlobal(F
, Mang
, TM
));
378 // Otherwise, drop it in the readonly section.
379 const MCSection
*ReadOnlySection
=
380 getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly());
381 SwitchToSection(ReadOnlySection
);
382 JTInDiffSection
= true;
385 EmitAlignment(Log2_32(MJTI
->getAlignment()));
387 for (unsigned i
= 0, e
= JT
.size(); i
!= e
; ++i
) {
388 const std::vector
<MachineBasicBlock
*> &JTBBs
= JT
[i
].MBBs
;
390 // If this jump table was deleted, ignore it.
391 if (JTBBs
.empty()) continue;
393 // For PIC codegen, if possible we want to use the SetDirective to reduce
394 // the number of relocations the assembler will generate for the jump table.
395 // Set directives are all printed before the jump table itself.
396 SmallPtrSet
<MachineBasicBlock
*, 16> EmittedSets
;
397 if (TAI
->getSetDirective() && IsPic
)
398 for (unsigned ii
= 0, ee
= JTBBs
.size(); ii
!= ee
; ++ii
)
399 if (EmittedSets
.insert(JTBBs
[ii
]))
400 printPICJumpTableSetLabel(i
, JTBBs
[ii
]);
402 // On some targets (e.g. darwin) we want to emit two consequtive labels
403 // before each jump table. The first label is never referenced, but tells
404 // the assembler and linker the extents of the jump table object. The
405 // second label is actually referenced by the code.
406 if (JTInDiffSection
) {
407 if (const char *JTLabelPrefix
= TAI
->getJumpTableSpecialLabelPrefix())
408 O
<< JTLabelPrefix
<< "JTI" << getFunctionNumber() << '_' << i
<< ":\n";
411 O
<< TAI
->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
412 << '_' << i
<< ":\n";
414 for (unsigned ii
= 0, ee
= JTBBs
.size(); ii
!= ee
; ++ii
) {
415 printPICJumpTableEntry(MJTI
, JTBBs
[ii
], i
);
421 void AsmPrinter::printPICJumpTableEntry(const MachineJumpTableInfo
*MJTI
,
422 const MachineBasicBlock
*MBB
,
423 unsigned uid
) const {
424 bool isPIC
= TM
.getRelocationModel() == Reloc::PIC_
;
426 // Use JumpTableDirective otherwise honor the entry size from the jump table
428 const char *JTEntryDirective
= TAI
->getJumpTableDirective(isPIC
);
429 bool HadJTEntryDirective
= JTEntryDirective
!= NULL
;
430 if (!HadJTEntryDirective
) {
431 JTEntryDirective
= MJTI
->getEntrySize() == 4 ?
432 TAI
->getData32bitsDirective() : TAI
->getData64bitsDirective();
435 O
<< JTEntryDirective
<< ' ';
437 // If we have emitted set directives for the jump table entries, print
438 // them rather than the entries themselves. If we're emitting PIC, then
439 // emit the table entries as differences between two text section labels.
440 // If we're emitting non-PIC code, then emit the entries as direct
441 // references to the target basic blocks.
443 printBasicBlockLabel(MBB
, false, false, false);
444 } else if (TAI
->getSetDirective()) {
445 O
<< TAI
->getPrivateGlobalPrefix() << getFunctionNumber()
446 << '_' << uid
<< "_set_" << MBB
->getNumber();
448 printBasicBlockLabel(MBB
, false, false, false);
449 // If the arch uses custom Jump Table directives, don't calc relative to
451 if (!HadJTEntryDirective
)
452 O
<< '-' << TAI
->getPrivateGlobalPrefix() << "JTI"
453 << getFunctionNumber() << '_' << uid
;
458 /// EmitSpecialLLVMGlobal - Check to see if the specified global is a
459 /// special global used by LLVM. If so, emit it and return true, otherwise
460 /// do nothing and return false.
461 bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable
*GV
) {
462 if (GV
->getName() == "llvm.used") {
463 if (TAI
->getUsedDirective() != 0) // No need to emit this at all.
464 EmitLLVMUsedList(GV
->getInitializer());
468 // Ignore debug and non-emitted data. This handles llvm.compiler.used.
469 if (GV
->getSection() == "llvm.metadata" ||
470 GV
->hasAvailableExternallyLinkage())
473 if (!GV
->hasAppendingLinkage()) return false;
475 assert(GV
->hasInitializer() && "Not a special LLVM global!");
477 const TargetData
*TD
= TM
.getTargetData();
478 unsigned Align
= Log2_32(TD
->getPointerPrefAlignment());
479 if (GV
->getName() == "llvm.global_ctors") {
480 SwitchToSection(getObjFileLowering().getStaticCtorSection());
481 EmitAlignment(Align
, 0);
482 EmitXXStructorList(GV
->getInitializer());
486 if (GV
->getName() == "llvm.global_dtors") {
487 SwitchToSection(getObjFileLowering().getStaticDtorSection());
488 EmitAlignment(Align
, 0);
489 EmitXXStructorList(GV
->getInitializer());
496 /// EmitLLVMUsedList - For targets that define a TAI::UsedDirective, mark each
497 /// global in the specified llvm.used list for which emitUsedDirectiveFor
498 /// is true, as being used with this directive.
499 void AsmPrinter::EmitLLVMUsedList(Constant
*List
) {
500 const char *Directive
= TAI
->getUsedDirective();
502 // Should be an array of 'i8*'.
503 ConstantArray
*InitList
= dyn_cast
<ConstantArray
>(List
);
504 if (InitList
== 0) return;
506 for (unsigned i
= 0, e
= InitList
->getNumOperands(); i
!= e
; ++i
) {
507 const GlobalValue
*GV
=
508 dyn_cast
<GlobalValue
>(InitList
->getOperand(i
)->stripPointerCasts());
509 if (GV
&& getObjFileLowering().shouldEmitUsedDirectiveFor(GV
, Mang
)) {
511 EmitConstantValueOnly(InitList
->getOperand(i
));
517 /// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the
518 /// function pointers, ignoring the init priority.
519 void AsmPrinter::EmitXXStructorList(Constant
*List
) {
520 // Should be an array of '{ int, void ()* }' structs. The first value is the
521 // init priority, which we ignore.
522 if (!isa
<ConstantArray
>(List
)) return;
523 ConstantArray
*InitList
= cast
<ConstantArray
>(List
);
524 for (unsigned i
= 0, e
= InitList
->getNumOperands(); i
!= e
; ++i
)
525 if (ConstantStruct
*CS
= dyn_cast
<ConstantStruct
>(InitList
->getOperand(i
))){
526 if (CS
->getNumOperands() != 2) return; // Not array of 2-element structs.
528 if (CS
->getOperand(1)->isNullValue())
529 return; // Found a null terminator, exit printing.
530 // Emit the function pointer.
531 EmitGlobalConstant(CS
->getOperand(1));
535 /// getGlobalLinkName - Returns the asm/link name of of the specified
536 /// global variable. Should be overridden by each target asm printer to
537 /// generate the appropriate value.
538 const std::string
&AsmPrinter::getGlobalLinkName(const GlobalVariable
*GV
,
539 std::string
&LinkName
) const {
540 if (isa
<Function
>(GV
)) {
541 LinkName
+= TAI
->getFunctionAddrPrefix();
542 LinkName
+= Mang
->getMangledName(GV
);
543 LinkName
+= TAI
->getFunctionAddrSuffix();
545 LinkName
+= TAI
->getGlobalVarAddrPrefix();
546 LinkName
+= Mang
->getMangledName(GV
);
547 LinkName
+= TAI
->getGlobalVarAddrSuffix();
553 /// EmitExternalGlobal - Emit the external reference to a global variable.
554 /// Should be overridden if an indirect reference should be used.
555 void AsmPrinter::EmitExternalGlobal(const GlobalVariable
*GV
) {
557 O
<< getGlobalLinkName(GV
, GLN
);
562 //===----------------------------------------------------------------------===//
563 /// LEB 128 number encoding.
565 /// PrintULEB128 - Print a series of hexidecimal values (separated by commas)
566 /// representing an unsigned leb128 value.
567 void AsmPrinter::PrintULEB128(unsigned Value
) const {
570 unsigned char Byte
= static_cast<unsigned char>(Value
& 0x7f);
572 if (Value
) Byte
|= 0x80;
573 O
<< "0x" << utohex_buffer(Byte
, Buffer
+20);
574 if (Value
) O
<< ", ";
578 /// PrintSLEB128 - Print a series of hexidecimal values (separated by commas)
579 /// representing a signed leb128 value.
580 void AsmPrinter::PrintSLEB128(int Value
) const {
581 int Sign
= Value
>> (8 * sizeof(Value
) - 1);
586 unsigned char Byte
= static_cast<unsigned char>(Value
& 0x7f);
588 IsMore
= Value
!= Sign
|| ((Byte
^ Sign
) & 0x40) != 0;
589 if (IsMore
) Byte
|= 0x80;
590 O
<< "0x" << utohex_buffer(Byte
, Buffer
+20);
591 if (IsMore
) O
<< ", ";
595 //===--------------------------------------------------------------------===//
596 // Emission and print routines
599 /// PrintHex - Print a value as a hexidecimal value.
601 void AsmPrinter::PrintHex(int Value
) const {
603 O
<< "0x" << utohex_buffer(static_cast<unsigned>(Value
), Buffer
+20);
606 /// EOL - Print a newline character to asm stream. If a comment is present
607 /// then it will be printed first. Comments should not contain '\n'.
608 void AsmPrinter::EOL() const {
612 void AsmPrinter::EOL(const std::string
&Comment
) const {
613 if (VerboseAsm
&& !Comment
.empty()) {
614 O
.PadToColumn(TAI
->getCommentColumn(), 1);
615 O
<< TAI
->getCommentString()
622 void AsmPrinter::EOL(const char* Comment
) const {
623 if (VerboseAsm
&& *Comment
) {
624 O
.PadToColumn(TAI
->getCommentColumn(), 1);
625 O
<< TAI
->getCommentString()
632 /// EmitULEB128Bytes - Emit an assembler byte data directive to compose an
633 /// unsigned leb128 value.
634 void AsmPrinter::EmitULEB128Bytes(unsigned Value
) const {
635 if (TAI
->hasLEB128()) {
639 O
<< TAI
->getData8bitsDirective();
644 /// EmitSLEB128Bytes - print an assembler byte data directive to compose a
645 /// signed leb128 value.
646 void AsmPrinter::EmitSLEB128Bytes(int Value
) const {
647 if (TAI
->hasLEB128()) {
651 O
<< TAI
->getData8bitsDirective();
656 /// EmitInt8 - Emit a byte directive and value.
658 void AsmPrinter::EmitInt8(int Value
) const {
659 O
<< TAI
->getData8bitsDirective();
660 PrintHex(Value
& 0xFF);
663 /// EmitInt16 - Emit a short directive and value.
665 void AsmPrinter::EmitInt16(int Value
) const {
666 O
<< TAI
->getData16bitsDirective();
667 PrintHex(Value
& 0xFFFF);
670 /// EmitInt32 - Emit a long directive and value.
672 void AsmPrinter::EmitInt32(int Value
) const {
673 O
<< TAI
->getData32bitsDirective();
677 /// EmitInt64 - Emit a long long directive and value.
679 void AsmPrinter::EmitInt64(uint64_t Value
) const {
680 if (TAI
->getData64bitsDirective()) {
681 O
<< TAI
->getData64bitsDirective();
684 if (TM
.getTargetData()->isBigEndian()) {
685 EmitInt32(unsigned(Value
>> 32)); O
<< '\n';
686 EmitInt32(unsigned(Value
));
688 EmitInt32(unsigned(Value
)); O
<< '\n';
689 EmitInt32(unsigned(Value
>> 32));
694 /// toOctal - Convert the low order bits of X into an octal digit.
696 static inline char toOctal(int X
) {
700 /// printStringChar - Print a char, escaped if necessary.
702 static void printStringChar(formatted_raw_ostream
&O
, unsigned char C
) {
705 } else if (C
== '\\') {
707 } else if (isprint((unsigned char)C
)) {
711 case '\b': O
<< "\\b"; break;
712 case '\f': O
<< "\\f"; break;
713 case '\n': O
<< "\\n"; break;
714 case '\r': O
<< "\\r"; break;
715 case '\t': O
<< "\\t"; break;
718 O
<< toOctal(C
>> 6);
719 O
<< toOctal(C
>> 3);
720 O
<< toOctal(C
>> 0);
726 /// EmitString - Emit a string with quotes and a null terminator.
727 /// Special characters are emitted properly.
728 /// \literal (Eg. '\t') \endliteral
729 void AsmPrinter::EmitString(const std::string
&String
) const {
730 EmitString(String
.c_str(), String
.size());
733 void AsmPrinter::EmitString(const char *String
, unsigned Size
) const {
734 const char* AscizDirective
= TAI
->getAscizDirective();
738 O
<< TAI
->getAsciiDirective();
740 for (unsigned i
= 0; i
< Size
; ++i
)
741 printStringChar(O
, String
[i
]);
749 /// EmitFile - Emit a .file directive.
750 void AsmPrinter::EmitFile(unsigned Number
, const std::string
&Name
) const {
751 O
<< "\t.file\t" << Number
<< " \"";
752 for (unsigned i
= 0, N
= Name
.size(); i
< N
; ++i
)
753 printStringChar(O
, Name
[i
]);
758 //===----------------------------------------------------------------------===//
760 // EmitAlignment - Emit an alignment directive to the specified power of
761 // two boundary. For example, if you pass in 3 here, you will get an 8
762 // byte alignment. If a global value is specified, and if that global has
763 // an explicit alignment requested, it will unconditionally override the
764 // alignment request. However, if ForcedAlignBits is specified, this value
765 // has final say: the ultimate alignment will be the max of ForcedAlignBits
766 // and the alignment computed with NumBits and the global.
770 // if (GV && GV->hasalignment) Align = GV->getalignment();
771 // Align = std::max(Align, ForcedAlignBits);
773 void AsmPrinter::EmitAlignment(unsigned NumBits
, const GlobalValue
*GV
,
774 unsigned ForcedAlignBits
,
775 bool UseFillExpr
) const {
776 if (GV
&& GV
->getAlignment())
777 NumBits
= Log2_32(GV
->getAlignment());
778 NumBits
= std::max(NumBits
, ForcedAlignBits
);
780 if (NumBits
== 0) return; // No need to emit alignment.
781 if (TAI
->getAlignmentIsInBytes()) NumBits
= 1 << NumBits
;
782 O
<< TAI
->getAlignDirective() << NumBits
;
784 if (CurrentSection
&& CurrentSection
->getKind().isText())
785 if (unsigned FillValue
= TAI
->getTextAlignFillValue()) {
792 /// EmitZeros - Emit a block of zeros.
794 void AsmPrinter::EmitZeros(uint64_t NumZeros
, unsigned AddrSpace
) const {
796 if (TAI
->getZeroDirective()) {
797 O
<< TAI
->getZeroDirective() << NumZeros
;
798 if (TAI
->getZeroDirectiveSuffix())
799 O
<< TAI
->getZeroDirectiveSuffix();
802 for (; NumZeros
; --NumZeros
)
803 O
<< TAI
->getData8bitsDirective(AddrSpace
) << "0\n";
808 // Print out the specified constant, without a storage class. Only the
809 // constants valid in constant expressions can occur here.
810 void AsmPrinter::EmitConstantValueOnly(const Constant
*CV
) {
811 if (CV
->isNullValue() || isa
<UndefValue
>(CV
))
813 else if (const ConstantInt
*CI
= dyn_cast
<ConstantInt
>(CV
)) {
814 O
<< CI
->getZExtValue();
815 } else if (const GlobalValue
*GV
= dyn_cast
<GlobalValue
>(CV
)) {
816 // This is a constant address for a global variable or function. Use the
817 // name of the variable or function as the address value, possibly
818 // decorating it with GlobalVarAddrPrefix/Suffix or
819 // FunctionAddrPrefix/Suffix (these all default to "" )
820 if (isa
<Function
>(GV
)) {
821 O
<< TAI
->getFunctionAddrPrefix()
822 << Mang
->getMangledName(GV
)
823 << TAI
->getFunctionAddrSuffix();
825 O
<< TAI
->getGlobalVarAddrPrefix()
826 << Mang
->getMangledName(GV
)
827 << TAI
->getGlobalVarAddrSuffix();
829 } else if (const ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(CV
)) {
830 const TargetData
*TD
= TM
.getTargetData();
831 unsigned Opcode
= CE
->getOpcode();
833 case Instruction::Trunc
:
834 case Instruction::ZExt
:
835 case Instruction::SExt
:
836 case Instruction::FPTrunc
:
837 case Instruction::FPExt
:
838 case Instruction::UIToFP
:
839 case Instruction::SIToFP
:
840 case Instruction::FPToUI
:
841 case Instruction::FPToSI
:
842 llvm_unreachable("FIXME: Don't support this constant cast expr");
843 case Instruction::GetElementPtr
: {
844 // generate a symbolic expression for the byte address
845 const Constant
*ptrVal
= CE
->getOperand(0);
846 SmallVector
<Value
*, 8> idxVec(CE
->op_begin()+1, CE
->op_end());
847 if (int64_t Offset
= TD
->getIndexedOffset(ptrVal
->getType(), &idxVec
[0],
849 // Truncate/sext the offset to the pointer size.
850 if (TD
->getPointerSizeInBits() != 64) {
851 int SExtAmount
= 64-TD
->getPointerSizeInBits();
852 Offset
= (Offset
<< SExtAmount
) >> SExtAmount
;
857 EmitConstantValueOnly(ptrVal
);
859 O
<< ") + " << Offset
;
861 O
<< ") - " << -Offset
;
863 EmitConstantValueOnly(ptrVal
);
867 case Instruction::BitCast
:
868 return EmitConstantValueOnly(CE
->getOperand(0));
870 case Instruction::IntToPtr
: {
871 // Handle casts to pointers by changing them into casts to the appropriate
872 // integer type. This promotes constant folding and simplifies this code.
873 Constant
*Op
= CE
->getOperand(0);
874 Op
= ConstantExpr::getIntegerCast(Op
, TD
->getIntPtrType(CV
->getContext()),
876 return EmitConstantValueOnly(Op
);
880 case Instruction::PtrToInt
: {
881 // Support only foldable casts to/from pointers that can be eliminated by
882 // changing the pointer to the appropriately sized integer type.
883 Constant
*Op
= CE
->getOperand(0);
884 const Type
*Ty
= CE
->getType();
886 // We can emit the pointer value into this slot if the slot is an
887 // integer slot greater or equal to the size of the pointer.
888 if (TD
->getTypeAllocSize(Ty
) == TD
->getTypeAllocSize(Op
->getType()))
889 return EmitConstantValueOnly(Op
);
892 EmitConstantValueOnly(Op
);
894 APInt::getAllOnesValue(TD
->getTypeAllocSizeInBits(Op
->getType()));
897 ptrMask
.toStringUnsigned(S
);
898 O
<< ") & " << S
.c_str() << ')';
901 case Instruction::Add
:
902 case Instruction::Sub
:
903 case Instruction::And
:
904 case Instruction::Or
:
905 case Instruction::Xor
:
907 EmitConstantValueOnly(CE
->getOperand(0));
910 case Instruction::Add
:
913 case Instruction::Sub
:
916 case Instruction::And
:
919 case Instruction::Or
:
922 case Instruction::Xor
:
929 EmitConstantValueOnly(CE
->getOperand(1));
933 llvm_unreachable("Unsupported operator!");
936 llvm_unreachable("Unknown constant value!");
940 /// printAsCString - Print the specified array as a C compatible string, only if
941 /// the predicate isString is true.
943 static void printAsCString(formatted_raw_ostream
&O
, const ConstantArray
*CVA
,
945 assert(CVA
->isString() && "Array is not string compatible!");
948 for (unsigned i
= 0; i
!= LastElt
; ++i
) {
950 (unsigned char)cast
<ConstantInt
>(CVA
->getOperand(i
))->getZExtValue();
951 printStringChar(O
, C
);
956 /// EmitString - Emit a zero-byte-terminated string constant.
958 void AsmPrinter::EmitString(const ConstantArray
*CVA
) const {
959 unsigned NumElts
= CVA
->getNumOperands();
960 if (TAI
->getAscizDirective() && NumElts
&&
961 cast
<ConstantInt
>(CVA
->getOperand(NumElts
-1))->getZExtValue() == 0) {
962 O
<< TAI
->getAscizDirective();
963 printAsCString(O
, CVA
, NumElts
-1);
965 O
<< TAI
->getAsciiDirective();
966 printAsCString(O
, CVA
, NumElts
);
971 void AsmPrinter::EmitGlobalConstantArray(const ConstantArray
*CVA
,
972 unsigned AddrSpace
) {
973 if (CVA
->isString()) {
975 } else { // Not a string. Print the values in successive locations
976 for (unsigned i
= 0, e
= CVA
->getNumOperands(); i
!= e
; ++i
)
977 EmitGlobalConstant(CVA
->getOperand(i
), AddrSpace
);
981 void AsmPrinter::EmitGlobalConstantVector(const ConstantVector
*CP
) {
982 const VectorType
*PTy
= CP
->getType();
984 for (unsigned I
= 0, E
= PTy
->getNumElements(); I
< E
; ++I
)
985 EmitGlobalConstant(CP
->getOperand(I
));
988 void AsmPrinter::EmitGlobalConstantStruct(const ConstantStruct
*CVS
,
989 unsigned AddrSpace
) {
990 // Print the fields in successive locations. Pad to align if needed!
991 const TargetData
*TD
= TM
.getTargetData();
992 unsigned Size
= TD
->getTypeAllocSize(CVS
->getType());
993 const StructLayout
*cvsLayout
= TD
->getStructLayout(CVS
->getType());
994 uint64_t sizeSoFar
= 0;
995 for (unsigned i
= 0, e
= CVS
->getNumOperands(); i
!= e
; ++i
) {
996 const Constant
* field
= CVS
->getOperand(i
);
998 // Check if padding is needed and insert one or more 0s.
999 uint64_t fieldSize
= TD
->getTypeAllocSize(field
->getType());
1000 uint64_t padSize
= ((i
== e
-1 ? Size
: cvsLayout
->getElementOffset(i
+1))
1001 - cvsLayout
->getElementOffset(i
)) - fieldSize
;
1002 sizeSoFar
+= fieldSize
+ padSize
;
1004 // Now print the actual field value.
1005 EmitGlobalConstant(field
, AddrSpace
);
1007 // Insert padding - this may include padding to increase the size of the
1008 // current field up to the ABI size (if the struct is not packed) as well
1009 // as padding to ensure that the next field starts at the right offset.
1010 EmitZeros(padSize
, AddrSpace
);
1012 assert(sizeSoFar
== cvsLayout
->getSizeInBytes() &&
1013 "Layout of constant struct may be incorrect!");
1016 void AsmPrinter::EmitGlobalConstantFP(const ConstantFP
*CFP
,
1017 unsigned AddrSpace
) {
1018 // FP Constants are printed as integer constants to avoid losing
1020 LLVMContext
&Context
= CFP
->getContext();
1021 const TargetData
*TD
= TM
.getTargetData();
1022 if (CFP
->getType() == Type::getDoubleTy(Context
)) {
1023 double Val
= CFP
->getValueAPF().convertToDouble(); // for comment only
1024 uint64_t i
= CFP
->getValueAPF().bitcastToAPInt().getZExtValue();
1025 if (TAI
->getData64bitsDirective(AddrSpace
)) {
1026 O
<< TAI
->getData64bitsDirective(AddrSpace
) << i
;
1028 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1029 O
<< TAI
->getCommentString() << " double " << Val
;
1032 } else if (TD
->isBigEndian()) {
1033 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(i
>> 32);
1035 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1036 O
<< TAI
->getCommentString()
1037 << " most significant word of double " << Val
;
1040 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(i
);
1042 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1043 O
<< TAI
->getCommentString()
1044 << " least significant word of double " << Val
;
1048 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(i
);
1050 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1051 O
<< TAI
->getCommentString()
1052 << " least significant word of double " << Val
;
1055 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(i
>> 32);
1057 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1058 O
<< TAI
->getCommentString()
1059 << " most significant word of double " << Val
;
1064 } else if (CFP
->getType() == Type::getFloatTy(Context
)) {
1065 float Val
= CFP
->getValueAPF().convertToFloat(); // for comment only
1066 O
<< TAI
->getData32bitsDirective(AddrSpace
)
1067 << CFP
->getValueAPF().bitcastToAPInt().getZExtValue();
1069 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1070 O
<< TAI
->getCommentString() << " float " << Val
;
1074 } else if (CFP
->getType() == Type::getX86_FP80Ty(Context
)) {
1075 // all long double variants are printed as hex
1076 // api needed to prevent premature destruction
1077 APInt api
= CFP
->getValueAPF().bitcastToAPInt();
1078 const uint64_t *p
= api
.getRawData();
1079 // Convert to double so we can print the approximate val as a comment.
1080 APFloat DoubleVal
= CFP
->getValueAPF();
1082 DoubleVal
.convert(APFloat::IEEEdouble
, APFloat::rmNearestTiesToEven
,
1084 if (TD
->isBigEndian()) {
1085 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[1]);
1087 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1088 O
<< TAI
->getCommentString()
1089 << " most significant halfword of x86_fp80 ~"
1090 << DoubleVal
.convertToDouble();
1093 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 48);
1095 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1096 O
<< TAI
->getCommentString() << " next halfword";
1099 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 32);
1101 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1102 O
<< TAI
->getCommentString() << " next halfword";
1105 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 16);
1107 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1108 O
<< TAI
->getCommentString() << " next halfword";
1111 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0]);
1113 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1114 O
<< TAI
->getCommentString()
1115 << " least significant halfword";
1119 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0]);
1121 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1122 O
<< TAI
->getCommentString()
1123 << " least significant halfword of x86_fp80 ~"
1124 << DoubleVal
.convertToDouble();
1127 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 16);
1129 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1130 O
<< TAI
->getCommentString()
1131 << " next halfword";
1134 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 32);
1136 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1137 O
<< TAI
->getCommentString()
1138 << " next halfword";
1141 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[0] >> 48);
1143 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1144 O
<< TAI
->getCommentString()
1145 << " next halfword";
1148 O
<< TAI
->getData16bitsDirective(AddrSpace
) << uint16_t(p
[1]);
1150 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1151 O
<< TAI
->getCommentString()
1152 << " most significant halfword";
1156 EmitZeros(TD
->getTypeAllocSize(Type::getX86_FP80Ty(Context
)) -
1157 TD
->getTypeStoreSize(Type::getX86_FP80Ty(Context
)), AddrSpace
);
1159 } else if (CFP
->getType() == Type::getPPC_FP128Ty(Context
)) {
1160 // all long double variants are printed as hex
1161 // api needed to prevent premature destruction
1162 APInt api
= CFP
->getValueAPF().bitcastToAPInt();
1163 const uint64_t *p
= api
.getRawData();
1164 if (TD
->isBigEndian()) {
1165 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[0] >> 32);
1167 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1168 O
<< TAI
->getCommentString()
1169 << " most significant word of ppc_fp128";
1172 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[0]);
1174 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1175 O
<< TAI
->getCommentString()
1179 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[1] >> 32);
1181 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1182 O
<< TAI
->getCommentString()
1186 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[1]);
1188 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1189 O
<< TAI
->getCommentString()
1190 << " least significant word";
1194 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[1]);
1196 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1197 O
<< TAI
->getCommentString()
1198 << " least significant word of ppc_fp128";
1201 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[1] >> 32);
1203 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1204 O
<< TAI
->getCommentString()
1208 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[0]);
1210 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1211 O
<< TAI
->getCommentString()
1215 O
<< TAI
->getData32bitsDirective(AddrSpace
) << uint32_t(p
[0] >> 32);
1217 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1218 O
<< TAI
->getCommentString()
1219 << " most significant word";
1224 } else llvm_unreachable("Floating point constant type not handled");
1227 void AsmPrinter::EmitGlobalConstantLargeInt(const ConstantInt
*CI
,
1228 unsigned AddrSpace
) {
1229 const TargetData
*TD
= TM
.getTargetData();
1230 unsigned BitWidth
= CI
->getBitWidth();
1231 assert(isPowerOf2_32(BitWidth
) &&
1232 "Non-power-of-2-sized integers not handled!");
1234 // We don't expect assemblers to support integer data directives
1235 // for more than 64 bits, so we emit the data in at most 64-bit
1236 // quantities at a time.
1237 const uint64_t *RawData
= CI
->getValue().getRawData();
1238 for (unsigned i
= 0, e
= BitWidth
/ 64; i
!= e
; ++i
) {
1240 if (TD
->isBigEndian())
1241 Val
= RawData
[e
- i
- 1];
1245 if (TAI
->getData64bitsDirective(AddrSpace
))
1246 O
<< TAI
->getData64bitsDirective(AddrSpace
) << Val
<< '\n';
1247 else if (TD
->isBigEndian()) {
1248 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(Val
>> 32);
1250 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1251 O
<< TAI
->getCommentString()
1252 << " most significant half of i64 " << Val
;
1255 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(Val
);
1257 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1258 O
<< TAI
->getCommentString()
1259 << " least significant half of i64 " << Val
;
1263 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(Val
);
1265 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1266 O
<< TAI
->getCommentString()
1267 << " least significant half of i64 " << Val
;
1270 O
<< TAI
->getData32bitsDirective(AddrSpace
) << unsigned(Val
>> 32);
1272 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1273 O
<< TAI
->getCommentString()
1274 << " most significant half of i64 " << Val
;
1281 /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
1282 void AsmPrinter::EmitGlobalConstant(const Constant
*CV
, unsigned AddrSpace
) {
1283 const TargetData
*TD
= TM
.getTargetData();
1284 const Type
*type
= CV
->getType();
1285 unsigned Size
= TD
->getTypeAllocSize(type
);
1287 if (CV
->isNullValue() || isa
<UndefValue
>(CV
)) {
1288 EmitZeros(Size
, AddrSpace
);
1290 } else if (const ConstantArray
*CVA
= dyn_cast
<ConstantArray
>(CV
)) {
1291 EmitGlobalConstantArray(CVA
, AddrSpace
);
1293 } else if (const ConstantStruct
*CVS
= dyn_cast
<ConstantStruct
>(CV
)) {
1294 EmitGlobalConstantStruct(CVS
, AddrSpace
);
1296 } else if (const ConstantFP
*CFP
= dyn_cast
<ConstantFP
>(CV
)) {
1297 EmitGlobalConstantFP(CFP
, AddrSpace
);
1299 } else if (const ConstantInt
*CI
= dyn_cast
<ConstantInt
>(CV
)) {
1300 // Small integers are handled below; large integers are handled here.
1302 EmitGlobalConstantLargeInt(CI
, AddrSpace
);
1305 } else if (const ConstantVector
*CP
= dyn_cast
<ConstantVector
>(CV
)) {
1306 EmitGlobalConstantVector(CP
);
1310 printDataDirective(type
, AddrSpace
);
1311 EmitConstantValueOnly(CV
);
1313 if (const ConstantInt
*CI
= dyn_cast
<ConstantInt
>(CV
)) {
1315 CI
->getValue().toStringUnsigned(S
, 16);
1316 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1317 O
<< TAI
->getCommentString() << " 0x" << S
.c_str();
1323 void AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue
*MCPV
) {
1324 // Target doesn't support this yet!
1325 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");
1328 /// PrintSpecial - Print information related to the specified machine instr
1329 /// that is independent of the operand, and may be independent of the instr
1330 /// itself. This can be useful for portably encoding the comment character
1331 /// or other bits of target-specific knowledge into the asmstrings. The
1332 /// syntax used is ${:comment}. Targets can override this to add support
1333 /// for their own strange codes.
1334 void AsmPrinter::PrintSpecial(const MachineInstr
*MI
, const char *Code
) const {
1335 if (!strcmp(Code
, "private")) {
1336 O
<< TAI
->getPrivateGlobalPrefix();
1337 } else if (!strcmp(Code
, "comment")) {
1339 O
<< TAI
->getCommentString();
1340 } else if (!strcmp(Code
, "uid")) {
1341 // Comparing the address of MI isn't sufficient, because machineinstrs may
1342 // be allocated to the same address across functions.
1343 const Function
*ThisF
= MI
->getParent()->getParent()->getFunction();
1345 // If this is a new LastFn instruction, bump the counter.
1346 if (LastMI
!= MI
|| LastFn
!= ThisF
) {
1354 raw_string_ostream
Msg(msg
);
1355 Msg
<< "Unknown special formatter '" << Code
1356 << "' for machine instr: " << *MI
;
1357 llvm_report_error(Msg
.str());
1361 /// processDebugLoc - Processes the debug information of each machine
1362 /// instruction's DebugLoc.
1363 void AsmPrinter::processDebugLoc(DebugLoc DL
) {
1367 if (TAI
->doesSupportDebugInformation() && DW
->ShouldEmitDwarfDebug()) {
1368 if (!DL
.isUnknown()) {
1369 DebugLocTuple CurDLT
= MF
->getDebugLocTuple(DL
);
1371 if (CurDLT
.CompileUnit
!= 0 && PrevDLT
!= CurDLT
)
1372 printLabel(DW
->RecordSourceLine(CurDLT
.Line
, CurDLT
.Col
,
1373 DICompileUnit(CurDLT
.CompileUnit
)));
1380 /// printInlineAsm - This method formats and prints the specified machine
1381 /// instruction that is an inline asm.
1382 void AsmPrinter::printInlineAsm(const MachineInstr
*MI
) const {
1383 unsigned NumOperands
= MI
->getNumOperands();
1385 // Count the number of register definitions.
1386 unsigned NumDefs
= 0;
1387 for (; MI
->getOperand(NumDefs
).isReg() && MI
->getOperand(NumDefs
).isDef();
1389 assert(NumDefs
!= NumOperands
-1 && "No asm string?");
1391 assert(MI
->getOperand(NumDefs
).isSymbol() && "No asm string?");
1393 // Disassemble the AsmStr, printing out the literal pieces, the operands, etc.
1394 const char *AsmStr
= MI
->getOperand(NumDefs
).getSymbolName();
1396 // If this asmstr is empty, just print the #APP/#NOAPP markers.
1397 // These are useful to see where empty asm's wound up.
1398 if (AsmStr
[0] == 0) {
1399 O
<< TAI
->getCommentString() << TAI
->getInlineAsmStart() << "\n\t";
1400 O
<< TAI
->getCommentString() << TAI
->getInlineAsmEnd() << '\n';
1404 O
<< TAI
->getCommentString() << TAI
->getInlineAsmStart() << "\n\t";
1406 // The variant of the current asmprinter.
1407 int AsmPrinterVariant
= TAI
->getAssemblerDialect();
1409 int CurVariant
= -1; // The number of the {.|.|.} region we are in.
1410 const char *LastEmitted
= AsmStr
; // One past the last character emitted.
1412 while (*LastEmitted
) {
1413 switch (*LastEmitted
) {
1415 // Not a special case, emit the string section literally.
1416 const char *LiteralEnd
= LastEmitted
+1;
1417 while (*LiteralEnd
&& *LiteralEnd
!= '{' && *LiteralEnd
!= '|' &&
1418 *LiteralEnd
!= '}' && *LiteralEnd
!= '$' && *LiteralEnd
!= '\n')
1420 if (CurVariant
== -1 || CurVariant
== AsmPrinterVariant
)
1421 O
.write(LastEmitted
, LiteralEnd
-LastEmitted
);
1422 LastEmitted
= LiteralEnd
;
1426 ++LastEmitted
; // Consume newline character.
1427 O
<< '\n'; // Indent code with newline.
1430 ++LastEmitted
; // Consume '$' character.
1434 switch (*LastEmitted
) {
1435 default: Done
= false; break;
1436 case '$': // $$ -> $
1437 if (CurVariant
== -1 || CurVariant
== AsmPrinterVariant
)
1439 ++LastEmitted
; // Consume second '$' character.
1441 case '(': // $( -> same as GCC's { character.
1442 ++LastEmitted
; // Consume '(' character.
1443 if (CurVariant
!= -1) {
1444 llvm_report_error("Nested variants found in inline asm string: '"
1445 + std::string(AsmStr
) + "'");
1447 CurVariant
= 0; // We're in the first variant now.
1450 ++LastEmitted
; // consume '|' character.
1451 if (CurVariant
== -1)
1452 O
<< '|'; // this is gcc's behavior for | outside a variant
1454 ++CurVariant
; // We're in the next variant.
1456 case ')': // $) -> same as GCC's } char.
1457 ++LastEmitted
; // consume ')' character.
1458 if (CurVariant
== -1)
1459 O
<< '}'; // this is gcc's behavior for } outside a variant
1466 bool HasCurlyBraces
= false;
1467 if (*LastEmitted
== '{') { // ${variable}
1468 ++LastEmitted
; // Consume '{' character.
1469 HasCurlyBraces
= true;
1472 // If we have ${:foo}, then this is not a real operand reference, it is a
1473 // "magic" string reference, just like in .td files. Arrange to call
1475 if (HasCurlyBraces
&& *LastEmitted
== ':') {
1477 const char *StrStart
= LastEmitted
;
1478 const char *StrEnd
= strchr(StrStart
, '}');
1480 llvm_report_error("Unterminated ${:foo} operand in inline asm string: '"
1481 + std::string(AsmStr
) + "'");
1484 std::string
Val(StrStart
, StrEnd
);
1485 PrintSpecial(MI
, Val
.c_str());
1486 LastEmitted
= StrEnd
+1;
1490 const char *IDStart
= LastEmitted
;
1493 long Val
= strtol(IDStart
, &IDEnd
, 10); // We only accept numbers for IDs.
1494 if (!isdigit(*IDStart
) || (Val
== 0 && errno
== EINVAL
)) {
1495 llvm_report_error("Bad $ operand number in inline asm string: '"
1496 + std::string(AsmStr
) + "'");
1498 LastEmitted
= IDEnd
;
1500 char Modifier
[2] = { 0, 0 };
1502 if (HasCurlyBraces
) {
1503 // If we have curly braces, check for a modifier character. This
1504 // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm.
1505 if (*LastEmitted
== ':') {
1506 ++LastEmitted
; // Consume ':' character.
1507 if (*LastEmitted
== 0) {
1508 llvm_report_error("Bad ${:} expression in inline asm string: '"
1509 + std::string(AsmStr
) + "'");
1512 Modifier
[0] = *LastEmitted
;
1513 ++LastEmitted
; // Consume modifier character.
1516 if (*LastEmitted
!= '}') {
1517 llvm_report_error("Bad ${} expression in inline asm string: '"
1518 + std::string(AsmStr
) + "'");
1520 ++LastEmitted
; // Consume '}' character.
1523 if ((unsigned)Val
>= NumOperands
-1) {
1524 llvm_report_error("Invalid $ operand number in inline asm string: '"
1525 + std::string(AsmStr
) + "'");
1528 // Okay, we finally have a value number. Ask the target to print this
1530 if (CurVariant
== -1 || CurVariant
== AsmPrinterVariant
) {
1535 // Scan to find the machine operand number for the operand.
1536 for (; Val
; --Val
) {
1537 if (OpNo
>= MI
->getNumOperands()) break;
1538 unsigned OpFlags
= MI
->getOperand(OpNo
).getImm();
1539 OpNo
+= InlineAsm::getNumOperandRegisters(OpFlags
) + 1;
1542 if (OpNo
>= MI
->getNumOperands()) {
1545 unsigned OpFlags
= MI
->getOperand(OpNo
).getImm();
1546 ++OpNo
; // Skip over the ID number.
1548 if (Modifier
[0]=='l') // labels are target independent
1549 printBasicBlockLabel(MI
->getOperand(OpNo
).getMBB(),
1550 false, false, false);
1552 AsmPrinter
*AP
= const_cast<AsmPrinter
*>(this);
1553 if ((OpFlags
& 7) == 4) {
1554 Error
= AP
->PrintAsmMemoryOperand(MI
, OpNo
, AsmPrinterVariant
,
1555 Modifier
[0] ? Modifier
: 0);
1557 Error
= AP
->PrintAsmOperand(MI
, OpNo
, AsmPrinterVariant
,
1558 Modifier
[0] ? Modifier
: 0);
1564 raw_string_ostream
Msg(msg
);
1565 Msg
<< "Invalid operand found in inline asm: '"
1568 llvm_report_error(Msg
.str());
1575 O
<< "\n\t" << TAI
->getCommentString() << TAI
->getInlineAsmEnd() << '\n';
1578 /// printImplicitDef - This method prints the specified machine instruction
1579 /// that is an implicit def.
1580 void AsmPrinter::printImplicitDef(const MachineInstr
*MI
) const {
1582 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1583 O
<< TAI
->getCommentString() << " implicit-def: "
1584 << TRI
->getAsmName(MI
->getOperand(0).getReg()) << '\n';
1588 /// printLabel - This method prints a local label used by debug and
1589 /// exception handling tables.
1590 void AsmPrinter::printLabel(const MachineInstr
*MI
) const {
1591 printLabel(MI
->getOperand(0).getImm());
1594 void AsmPrinter::printLabel(unsigned Id
) const {
1595 O
<< TAI
->getPrivateGlobalPrefix() << "label" << Id
<< ":\n";
1598 /// printDeclare - This method prints a local variable declaration used by
1600 /// FIXME: It doesn't really print anything rather it inserts a DebugVariable
1601 /// entry into dwarf table.
1602 void AsmPrinter::printDeclare(const MachineInstr
*MI
) const {
1603 unsigned FI
= MI
->getOperand(0).getIndex();
1604 GlobalValue
*GV
= MI
->getOperand(1).getGlobal();
1605 DW
->RecordVariable(cast
<GlobalVariable
>(GV
), FI
, MI
);
1608 /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM
1609 /// instruction, using the specified assembler variant. Targets should
1610 /// overried this to format as appropriate.
1611 bool AsmPrinter::PrintAsmOperand(const MachineInstr
*MI
, unsigned OpNo
,
1612 unsigned AsmVariant
, const char *ExtraCode
) {
1613 // Target doesn't support this yet!
1617 bool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr
*MI
, unsigned OpNo
,
1618 unsigned AsmVariant
,
1619 const char *ExtraCode
) {
1620 // Target doesn't support this yet!
1624 /// printBasicBlockLabel - This method prints the label for the specified
1625 /// MachineBasicBlock
1626 void AsmPrinter::printBasicBlockLabel(const MachineBasicBlock
*MBB
,
1629 bool printComment
) const {
1631 unsigned Align
= MBB
->getAlignment();
1633 EmitAlignment(Log2_32(Align
));
1636 O
<< TAI
->getPrivateGlobalPrefix() << "BB" << getFunctionNumber() << '_'
1637 << MBB
->getNumber();
1641 if (const BasicBlock
*BB
= MBB
->getBasicBlock())
1642 if (BB
->hasName()) {
1643 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1644 O
<< TAI
->getCommentString() << ' ';
1645 WriteAsOperand(O
, BB
, /*PrintType=*/false);
1653 /// printPICJumpTableSetLabel - This method prints a set label for the
1654 /// specified MachineBasicBlock for a jumptable entry.
1655 void AsmPrinter::printPICJumpTableSetLabel(unsigned uid
,
1656 const MachineBasicBlock
*MBB
) const {
1657 if (!TAI
->getSetDirective())
1660 O
<< TAI
->getSetDirective() << ' ' << TAI
->getPrivateGlobalPrefix()
1661 << getFunctionNumber() << '_' << uid
<< "_set_" << MBB
->getNumber() << ',';
1662 printBasicBlockLabel(MBB
, false, false, false);
1663 O
<< '-' << TAI
->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
1664 << '_' << uid
<< '\n';
1667 void AsmPrinter::printPICJumpTableSetLabel(unsigned uid
, unsigned uid2
,
1668 const MachineBasicBlock
*MBB
) const {
1669 if (!TAI
->getSetDirective())
1672 O
<< TAI
->getSetDirective() << ' ' << TAI
->getPrivateGlobalPrefix()
1673 << getFunctionNumber() << '_' << uid
<< '_' << uid2
1674 << "_set_" << MBB
->getNumber() << ',';
1675 printBasicBlockLabel(MBB
, false, false, false);
1676 O
<< '-' << TAI
->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber()
1677 << '_' << uid
<< '_' << uid2
<< '\n';
1680 /// printDataDirective - This method prints the asm directive for the
1682 void AsmPrinter::printDataDirective(const Type
*type
, unsigned AddrSpace
) {
1683 const TargetData
*TD
= TM
.getTargetData();
1684 switch (type
->getTypeID()) {
1685 case Type::FloatTyID
: case Type::DoubleTyID
:
1686 case Type::X86_FP80TyID
: case Type::FP128TyID
: case Type::PPC_FP128TyID
:
1687 assert(0 && "Should have already output floating point constant.");
1689 assert(0 && "Can't handle printing this type of thing");
1690 case Type::IntegerTyID
: {
1691 unsigned BitWidth
= cast
<IntegerType
>(type
)->getBitWidth();
1693 O
<< TAI
->getData8bitsDirective(AddrSpace
);
1694 else if (BitWidth
<= 16)
1695 O
<< TAI
->getData16bitsDirective(AddrSpace
);
1696 else if (BitWidth
<= 32)
1697 O
<< TAI
->getData32bitsDirective(AddrSpace
);
1698 else if (BitWidth
<= 64) {
1699 assert(TAI
->getData64bitsDirective(AddrSpace
) &&
1700 "Target cannot handle 64-bit constant exprs!");
1701 O
<< TAI
->getData64bitsDirective(AddrSpace
);
1703 llvm_unreachable("Target cannot handle given data directive width!");
1707 case Type::PointerTyID
:
1708 if (TD
->getPointerSize() == 8) {
1709 assert(TAI
->getData64bitsDirective(AddrSpace
) &&
1710 "Target cannot handle 64-bit pointer exprs!");
1711 O
<< TAI
->getData64bitsDirective(AddrSpace
);
1712 } else if (TD
->getPointerSize() == 2) {
1713 O
<< TAI
->getData16bitsDirective(AddrSpace
);
1714 } else if (TD
->getPointerSize() == 1) {
1715 O
<< TAI
->getData8bitsDirective(AddrSpace
);
1717 O
<< TAI
->getData32bitsDirective(AddrSpace
);
1723 void AsmPrinter::printVisibility(const std::string
& Name
,
1724 unsigned Visibility
) const {
1725 if (Visibility
== GlobalValue::HiddenVisibility
) {
1726 if (const char *Directive
= TAI
->getHiddenDirective())
1727 O
<< Directive
<< Name
<< '\n';
1728 } else if (Visibility
== GlobalValue::ProtectedVisibility
) {
1729 if (const char *Directive
= TAI
->getProtectedDirective())
1730 O
<< Directive
<< Name
<< '\n';
1734 void AsmPrinter::printOffset(int64_t Offset
) const {
1737 else if (Offset
< 0)
1741 void AsmPrinter::printMCInst(const MCInst
*MI
) {
1742 llvm_unreachable("MCInst printing unavailable on this target!");
1745 GCMetadataPrinter
*AsmPrinter::GetOrCreateGCPrinter(GCStrategy
*S
) {
1746 if (!S
->usesMetadata())
1749 gcp_iterator GCPI
= GCMetadataPrinters
.find(S
);
1750 if (GCPI
!= GCMetadataPrinters
.end())
1751 return GCPI
->second
;
1753 const char *Name
= S
->getName().c_str();
1755 for (GCMetadataPrinterRegistry::iterator
1756 I
= GCMetadataPrinterRegistry::begin(),
1757 E
= GCMetadataPrinterRegistry::end(); I
!= E
; ++I
)
1758 if (strcmp(Name
, I
->getName()) == 0) {
1759 GCMetadataPrinter
*GMP
= I
->instantiate();
1761 GCMetadataPrinters
.insert(std::make_pair(S
, GMP
));
1765 cerr
<< "no GCMetadataPrinter registered for GC: " << Name
<< "\n";
1766 llvm_unreachable(0);
1769 /// EmitComments - Pretty-print comments for instructions
1770 void AsmPrinter::EmitComments(const MachineInstr
&MI
) const {
1772 MI
.getDebugLoc().isUnknown())
1775 DebugLocTuple DLT
= MF
->getDebugLocTuple(MI
.getDebugLoc());
1777 // Print source line info
1778 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1779 O
<< TAI
->getCommentString() << " SrcLine ";
1780 if (DLT
.CompileUnit
->hasInitializer()) {
1781 Constant
*Name
= DLT
.CompileUnit
->getInitializer();
1782 if (ConstantArray
*NameString
= dyn_cast
<ConstantArray
>(Name
))
1783 if (NameString
->isString())
1784 O
<< NameString
->getAsString() << " ";
1788 O
<< ":" << DLT
.Col
;
1791 /// EmitComments - Pretty-print comments for instructions
1792 void AsmPrinter::EmitComments(const MCInst
&MI
) const
1795 if (!MI
.getDebugLoc().isUnknown()) {
1796 DebugLocTuple DLT
= MF
->getDebugLocTuple(MI
.getDebugLoc());
1798 // Print source line info
1799 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1800 O
<< TAI
->getCommentString() << " SrcLine ";
1801 if (DLT
.CompileUnit
->hasInitializer()) {
1802 Constant
*Name
= DLT
.CompileUnit
->getInitializer();
1803 if (ConstantArray
*NameString
= dyn_cast
<ConstantArray
>(Name
))
1804 if (NameString
->isString()) {
1805 O
<< NameString
->getAsString() << " ";
1810 O
<< ":" << DLT
.Col
;
1815 /// EmitComments - Pretty-print comments for basic blocks
1816 void AsmPrinter::EmitComments(const MachineBasicBlock
&MBB
) const
1819 // Add loop depth information
1820 const MachineLoop
*loop
= LI
->getLoopFor(&MBB
);
1823 // Print a newline after bb# annotation.
1825 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1826 O
<< TAI
->getCommentString() << " Loop Depth " << loop
->getLoopDepth()
1829 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1831 MachineBasicBlock
*Header
= loop
->getHeader();
1832 assert(Header
&& "No header for loop");
1834 if (Header
== &MBB
) {
1835 O
<< TAI
->getCommentString() << " Loop Header";
1836 PrintChildLoopComment(loop
);
1839 O
<< TAI
->getCommentString() << " Loop Header is BB"
1840 << getFunctionNumber() << "_" << loop
->getHeader()->getNumber();
1843 if (loop
->empty()) {
1845 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1846 O
<< TAI
->getCommentString() << " Inner Loop";
1849 // Add parent loop information
1850 for (const MachineLoop
*CurLoop
= loop
->getParentLoop();
1852 CurLoop
= CurLoop
->getParentLoop()) {
1853 MachineBasicBlock
*Header
= CurLoop
->getHeader();
1854 assert(Header
&& "No header for loop");
1857 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1858 O
<< TAI
->getCommentString() << Indent(CurLoop
->getLoopDepth()-1)
1859 << " Inside Loop BB" << getFunctionNumber() << "_"
1860 << Header
->getNumber() << " Depth " << CurLoop
->getLoopDepth();
1866 void AsmPrinter::PrintChildLoopComment(const MachineLoop
*loop
) const {
1867 // Add child loop information
1868 for(MachineLoop::iterator cl
= loop
->begin(),
1869 clend
= loop
->end();
1872 MachineBasicBlock
*Header
= (*cl
)->getHeader();
1873 assert(Header
&& "No header for loop");
1876 O
.PadToColumn(TAI
->getCommentColumn(), 1);
1878 O
<< TAI
->getCommentString() << Indent((*cl
)->getLoopDepth()-1)
1879 << " Child Loop BB" << getFunctionNumber() << "_"
1880 << Header
->getNumber() << " Depth " << (*cl
)->getLoopDepth();
1882 PrintChildLoopComment(*cl
);