blob: 4de98da655bc91c10e6edd61c4d62724133007e7 [file] [log] [blame]
Chris Lattnerc0561f22010-04-07 18:10:38 +00001//===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===//
Chris Lattnera80ba712004-08-16 23:15:22 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner4ee451d2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnera80ba712004-08-16 23:15:22 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the AsmPrinter class.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner14c38ec2010-01-28 01:02:27 +000014#define DEBUG_TYPE "asm-printer"
Evan Cheng932f0222006-03-03 02:04:29 +000015#include "llvm/CodeGen/AsmPrinter.h"
Chris Lattner49cd6642010-04-05 05:11:15 +000016#include "DwarfDebug.h"
17#include "DwarfException.h"
Bill Wendling0bcbd1d2012-06-28 00:05:13 +000018#include "llvm/DebugInfo.h"
Chris Lattner450de392005-11-10 18:36:17 +000019#include "llvm/Module.h"
Gordon Henriksen5eca0752008-08-17 18:44:35 +000020#include "llvm/CodeGen/GCMetadataPrinter.h"
Chris Lattner3b4fd322005-11-21 08:25:09 +000021#include "llvm/CodeGen/MachineConstantPool.h"
David Greene1924aab2009-11-13 21:34:57 +000022#include "llvm/CodeGen/MachineFrameInfo.h"
David Greenefe37ab32009-08-18 19:22:55 +000023#include "llvm/CodeGen/MachineFunction.h"
Nate Begeman37efe672006-04-22 18:53:45 +000024#include "llvm/CodeGen/MachineJumpTableInfo.h"
David Greeneb71d1b22009-08-10 16:38:07 +000025#include "llvm/CodeGen/MachineLoopInfo.h"
Chris Lattner84bc5422007-12-31 04:13:23 +000026#include "llvm/CodeGen/MachineModuleInfo.h"
Dan Gohman618f1772010-02-08 22:02:38 +000027#include "llvm/Analysis/ConstantFolding.h"
Chris Lattner736e31d2010-04-04 18:34:07 +000028#include "llvm/MC/MCAsmInfo.h"
Chris Lattner2b2954f2009-07-27 21:28:04 +000029#include "llvm/MC/MCContext.h"
Chris Lattner52492ac2010-01-23 06:17:14 +000030#include "llvm/MC/MCExpr.h"
David Greene3ac1ab82009-07-16 22:24:20 +000031#include "llvm/MC/MCInst.h"
Chris Lattnera87dea42009-07-31 18:48:30 +000032#include "llvm/MC/MCSection.h"
33#include "llvm/MC/MCStreamer.h"
Chris Lattner7cb384d2009-09-12 23:02:08 +000034#include "llvm/MC/MCSymbol.h"
Chris Lattner45111d12010-01-16 21:57:06 +000035#include "llvm/Target/Mangler.h"
Micah Villmow3574eca2012-10-08 16:38:25 +000036#include "llvm/DataLayout.h"
David Greene1924aab2009-11-13 21:34:57 +000037#include "llvm/Target/TargetInstrInfo.h"
Chris Lattner0336fdb2006-10-06 22:50:56 +000038#include "llvm/Target/TargetLowering.h"
Chris Lattnerf0144122009-07-28 03:13:23 +000039#include "llvm/Target/TargetLoweringObjectFile.h"
Rafael Espindolaa4329972011-04-29 14:14:06 +000040#include "llvm/Target/TargetOptions.h"
Evan Chengda47e6e2008-03-15 00:03:38 +000041#include "llvm/Target/TargetRegisterInfo.h"
Chris Lattner9fc5cdf2011-01-02 22:09:33 +000042#include "llvm/Assembly/Writer.h"
Chris Lattnerfad86b02008-08-17 07:19:36 +000043#include "llvm/ADT/SmallString.h"
Chris Lattner14c38ec2010-01-28 01:02:27 +000044#include "llvm/ADT/Statistic.h"
Chris Lattner14c38ec2010-01-28 01:02:27 +000045#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/Format.h"
David Greened92e2e42011-08-31 17:30:56 +000047#include "llvm/Support/MathExtras.h"
Torok Edwin9c421072010-04-07 10:44:46 +000048#include "llvm/Support/Timer.h"
Chris Lattnera80ba712004-08-16 23:15:22 +000049using namespace llvm;
50
Chris Lattnerc0561f22010-04-07 18:10:38 +000051static const char *DWARFGroupName = "DWARF Emission";
52static const char *DbgTimerName = "DWARF Debug Writer";
53static const char *EHTimerName = "DWARF Exception Writer";
Torok Edwin9c421072010-04-07 10:44:46 +000054
Chris Lattner14c38ec2010-01-28 01:02:27 +000055STATISTIC(EmittedInsts, "Number of machine instrs printed");
56
Devang Patel19974732007-05-03 01:11:54 +000057char AsmPrinter::ID = 0;
Chris Lattner11d53c12010-03-13 20:55:24 +000058
Chris Lattnere00b59f2010-04-04 17:57:56 +000059typedef DenseMap<GCStrategy*,GCMetadataPrinter*> gcp_map_type;
60static gcp_map_type &getGCMap(void *&P) {
61 if (P == 0)
62 P = new gcp_map_type();
63 return *(gcp_map_type*)P;
64}
65
66
Chris Lattnere87f7bb2010-04-28 19:58:07 +000067/// getGVAlignmentLog2 - Return the alignment to use for the specified global
68/// value in log2 form. This rounds up to the preferred alignment if possible
69/// and legal.
Micah Villmow3574eca2012-10-08 16:38:25 +000070static unsigned getGVAlignmentLog2(const GlobalValue *GV, const DataLayout &TD,
Chris Lattnere87f7bb2010-04-28 19:58:07 +000071 unsigned InBits = 0) {
72 unsigned NumBits = 0;
73 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
74 NumBits = TD.getPreferredAlignmentLog(GVar);
Jim Grosbach83d80832011-03-29 23:20:22 +000075
Chris Lattnere87f7bb2010-04-28 19:58:07 +000076 // If InBits is specified, round it to it.
77 if (InBits > NumBits)
78 NumBits = InBits;
Jim Grosbach83d80832011-03-29 23:20:22 +000079
Chris Lattnere87f7bb2010-04-28 19:58:07 +000080 // If the GV has a specified alignment, take it into account.
81 if (GV->getAlignment() == 0)
82 return NumBits;
Jim Grosbach83d80832011-03-29 23:20:22 +000083
Chris Lattnere87f7bb2010-04-28 19:58:07 +000084 unsigned GVAlign = Log2_32(GV->getAlignment());
Jim Grosbach83d80832011-03-29 23:20:22 +000085
Chris Lattnere87f7bb2010-04-28 19:58:07 +000086 // If the GVAlign is larger than NumBits, or if we are required to obey
87 // NumBits because the GV has an assigned section, obey it.
88 if (GVAlign > NumBits || GV->hasSection())
89 NumBits = GVAlign;
90 return NumBits;
91}
92
93
94
95
Chris Lattnerb23569a2010-04-04 08:18:47 +000096AsmPrinter::AsmPrinter(TargetMachine &tm, MCStreamer &Streamer)
Owen Anderson90c579d2010-08-06 18:33:48 +000097 : MachineFunctionPass(ID),
Chris Lattner9d1c1ad2010-04-04 18:06:11 +000098 TM(tm), MAI(tm.getMCAsmInfo()),
Chris Lattner11d53c12010-03-13 20:55:24 +000099 OutContext(Streamer.getContext()),
100 OutStreamer(Streamer),
Devang Patel553881b2010-03-29 17:20:31 +0000101 LastMI(0), LastFn(0), Counter(~0U), SetCounter(0) {
Chris Lattner49cd6642010-04-05 05:11:15 +0000102 DD = 0; DE = 0; MMI = 0; LI = 0;
Hal Finkeld55a2662012-02-22 21:11:47 +0000103 CurrentFnSym = CurrentFnSymForSize = 0;
Chris Lattnere00b59f2010-04-04 17:57:56 +0000104 GCMetadataPrinters = 0;
Chris Lattner56591ab2010-02-02 23:37:42 +0000105 VerboseAsm = Streamer.isVerboseAsm();
Evan Cheng42bf74b2009-03-25 01:47:28 +0000106}
Chris Lattnered138932005-12-13 06:32:10 +0000107
Gordon Henriksenc317a602008-08-17 12:08:44 +0000108AsmPrinter::~AsmPrinter() {
Chris Lattner49cd6642010-04-05 05:11:15 +0000109 assert(DD == 0 && DE == 0 && "Debug/EH info didn't get finalized");
Jim Grosbach83d80832011-03-29 23:20:22 +0000110
Chris Lattnere00b59f2010-04-04 17:57:56 +0000111 if (GCMetadataPrinters != 0) {
112 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters);
Jim Grosbach83d80832011-03-29 23:20:22 +0000113
Chris Lattnere00b59f2010-04-04 17:57:56 +0000114 for (gcp_map_type::iterator I = GCMap.begin(), E = GCMap.end(); I != E; ++I)
115 delete I->second;
116 delete &GCMap;
117 GCMetadataPrinters = 0;
118 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000119
Chris Lattner2b2954f2009-07-27 21:28:04 +0000120 delete &OutStreamer;
Gordon Henriksenc317a602008-08-17 12:08:44 +0000121}
Chris Lattnered138932005-12-13 06:32:10 +0000122
Chris Lattnerb84822f2010-01-26 04:35:26 +0000123/// getFunctionNumber - Return a unique ID for the current function.
124///
125unsigned AsmPrinter::getFunctionNumber() const {
126 return MF->getFunctionNumber();
127}
128
Dan Gohman0d805c32010-04-17 16:44:48 +0000129const TargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const {
Chris Lattnerf0144122009-07-28 03:13:23 +0000130 return TM.getTargetLowering()->getObjFileLowering();
131}
132
Chris Lattnerd38fee82010-04-05 00:13:49 +0000133
Micah Villmow3574eca2012-10-08 16:38:25 +0000134/// getDataLayout - Return information about data layout.
135const DataLayout &AsmPrinter::getDataLayout() const {
136 return *TM.getDataLayout();
Chris Lattnerd38fee82010-04-05 00:13:49 +0000137}
138
Chris Lattnerdabf07c2009-08-18 06:15:16 +0000139/// getCurrentSection() - Return the current section we are emitting to.
140const MCSection *AsmPrinter::getCurrentSection() const {
141 return OutStreamer.getCurrentSection();
142}
143
144
Chris Lattnerd38fee82010-04-05 00:13:49 +0000145
Gordon Henriksence224772008-01-07 01:30:38 +0000146void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const {
Dan Gohman845012e2009-07-31 23:37:33 +0000147 AU.setPreservesAll();
Gordon Henriksence224772008-01-07 01:30:38 +0000148 MachineFunctionPass::getAnalysisUsage(AU);
Chris Lattner11d53c12010-03-13 20:55:24 +0000149 AU.addRequired<MachineModuleInfo>();
Gordon Henriksen5eca0752008-08-17 18:44:35 +0000150 AU.addRequired<GCModuleInfo>();
Chris Lattner3f53c832010-04-04 18:52:31 +0000151 if (isVerbose())
David Greeneb71d1b22009-08-10 16:38:07 +0000152 AU.addRequired<MachineLoopInfo>();
Gordon Henriksence224772008-01-07 01:30:38 +0000153}
154
Chris Lattnera80ba712004-08-16 23:15:22 +0000155bool AsmPrinter::doInitialization(Module &M) {
Chris Lattnerd32c8a52010-04-04 05:09:10 +0000156 MMI = getAnalysisIfAvailable<MachineModuleInfo>();
Chris Lattner11d53c12010-03-13 20:55:24 +0000157 MMI->AnalyzeModule(M);
158
Chris Lattnerf26e03b2009-07-31 17:42:42 +0000159 // Initialize TargetLoweringObjectFile.
160 const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
161 .Initialize(OutContext, TM);
Jim Grosbach83d80832011-03-29 23:20:22 +0000162
Micah Villmow3574eca2012-10-08 16:38:25 +0000163 Mang = new Mangler(OutContext, *TM.getDataLayout());
Jim Grosbach83d80832011-03-29 23:20:22 +0000164
Bob Wilson812209a2009-09-30 22:06:26 +0000165 // Allow the target to emit any magic that it wants at the start of the file.
166 EmitStartOfAsmFile(M);
Rafael Espindola952b8392008-12-03 11:01:37 +0000167
Chris Lattnera6594fc2010-01-25 18:58:59 +0000168 // Very minimal debug info. It is ignored if we emit actual debug info. If we
169 // don't, this at least helps the user find where a global came from.
Chris Lattner33adcfb2009-08-22 21:43:10 +0000170 if (MAI->hasSingleParameterDotFile()) {
Chris Lattnera6594fc2010-01-25 18:58:59 +0000171 // .file "foo.c"
172 OutStreamer.EmitFileDirective(M.getModuleIdentifier());
Rafael Espindola952b8392008-12-03 11:01:37 +0000173 }
174
Bob Wilson812209a2009-09-30 22:06:26 +0000175 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
176 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
Gordon Henriksen5eca0752008-08-17 18:44:35 +0000177 for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I)
178 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I))
Chris Lattner7d73c7f2010-04-04 07:39:04 +0000179 MP->beginAssembly(*this);
Chris Lattner91bead72010-04-03 21:35:55 +0000180
181 // Emit module-level inline asm if it exists.
Chris Lattner47b7e5d2010-04-03 21:13:18 +0000182 if (!M.getModuleInlineAsm().empty()) {
183 OutStreamer.AddComment("Start of file scope inline assembly");
184 OutStreamer.AddBlankLine();
Chris Lattnera38941d2010-11-17 07:53:40 +0000185 EmitInlineAsm(M.getModuleInlineAsm()+"\n");
Chris Lattner47b7e5d2010-04-03 21:13:18 +0000186 OutStreamer.AddComment("End of file scope inline assembly");
187 OutStreamer.AddBlankLine();
188 }
Chris Lattner2c1b1592006-01-23 23:47:53 +0000189
Chris Lattner49cd6642010-04-05 05:11:15 +0000190 if (MAI->doesSupportDebugInformation())
191 DD = new DwarfDebug(this, &M);
Anton Korobeynikovd7e8ddc2011-01-14 21:57:45 +0000192
Rafael Espindola2d57a642011-05-05 19:48:34 +0000193 switch (MAI->getExceptionHandlingType()) {
194 case ExceptionHandling::None:
195 return false;
196 case ExceptionHandling::SjLj:
Rafael Espindola2d57a642011-05-05 19:48:34 +0000197 case ExceptionHandling::DwarfCFI:
198 DE = new DwarfCFIException(this);
199 return false;
200 case ExceptionHandling::ARM:
201 DE = new ARMException(this);
202 return false;
Charles Davisd652b132011-05-27 23:47:32 +0000203 case ExceptionHandling::Win64:
204 DE = new Win64Exception(this);
205 return false;
Rafael Espindola2d57a642011-05-05 19:48:34 +0000206 }
Devang Patel14a55d92009-06-19 21:54:26 +0000207
Rafael Espindola2d57a642011-05-05 19:48:34 +0000208 llvm_unreachable("Unknown exception type.");
Chris Lattnera80ba712004-08-16 23:15:22 +0000209}
210
Chris Lattnerbe9dfce2010-01-28 00:05:10 +0000211void AsmPrinter::EmitLinkage(unsigned Linkage, MCSymbol *GVSym) const {
Chris Lattnera3e88832010-01-26 23:47:12 +0000212 switch ((GlobalValue::LinkageTypes)Linkage) {
213 case GlobalValue::CommonLinkage:
214 case GlobalValue::LinkOnceAnyLinkage:
215 case GlobalValue::LinkOnceODRLinkage:
Bill Wendling32811be2012-08-17 18:33:14 +0000216 case GlobalValue::LinkOnceODRAutoHideLinkage:
Chris Lattnera3e88832010-01-26 23:47:12 +0000217 case GlobalValue::WeakAnyLinkage:
218 case GlobalValue::WeakODRLinkage:
Bill Wendling5e721d72010-07-01 21:55:59 +0000219 case GlobalValue::LinkerPrivateWeakLinkage:
Chris Lattnera3e88832010-01-26 23:47:12 +0000220 if (MAI->getWeakDefDirective() != 0) {
221 // .globl _foo
222 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
Bill Wendling55ae5152010-08-20 22:05:50 +0000223
224 if ((GlobalValue::LinkageTypes)Linkage !=
Bill Wendling32811be2012-08-17 18:33:14 +0000225 GlobalValue::LinkOnceODRAutoHideLinkage)
Bill Wendling55ae5152010-08-20 22:05:50 +0000226 // .weak_definition _foo
227 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition);
228 else
229 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate);
Duncan Sands5b1b3b72010-05-12 07:11:33 +0000230 } else if (MAI->getLinkOnceDirective() != 0) {
Chris Lattnera3e88832010-01-26 23:47:12 +0000231 // .globl _foo
232 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
Duncan Sands5b1b3b72010-05-12 07:11:33 +0000233 //NOTE: linkonce is handled by the section the symbol was assigned to.
Chris Lattnera3e88832010-01-26 23:47:12 +0000234 } else {
235 // .weak _foo
236 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak);
237 }
238 break;
239 case GlobalValue::DLLExportLinkage:
240 case GlobalValue::AppendingLinkage:
241 // FIXME: appending linkage variables should go into a section of
242 // their name or something. For now, just emit them as external.
243 case GlobalValue::ExternalLinkage:
244 // If external or appending, declare as a global symbol.
245 // .globl _foo
246 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
247 break;
248 case GlobalValue::PrivateLinkage:
249 case GlobalValue::InternalLinkage:
Bill Wendlingeabd7352010-07-01 22:38:24 +0000250 case GlobalValue::LinkerPrivateLinkage:
Chris Lattnera3e88832010-01-26 23:47:12 +0000251 break;
252 default:
253 llvm_unreachable("Unknown linkage type!");
254 }
255}
256
257
Chris Lattner48d64ba2010-01-19 04:39:15 +0000258/// EmitGlobalVariable - Emit the specified global variable to the .s file.
259void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
Rafael Espindola84397472011-04-05 15:51:32 +0000260 if (GV->hasInitializer()) {
261 // Check to see if this is a special global used by LLVM, if so, emit it.
262 if (EmitSpecialLLVMGlobal(GV))
263 return;
Jim Grosbach83d80832011-03-29 23:20:22 +0000264
Rafael Espindola84397472011-04-05 15:51:32 +0000265 if (isVerbose()) {
266 WriteAsOperand(OutStreamer.GetCommentOS(), GV,
267 /*PrintType=*/false, GV->getParent());
268 OutStreamer.GetCommentOS() << '\n';
269 }
Eric Christopher04386ca2010-05-25 21:49:43 +0000270 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000271
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000272 MCSymbol *GVSym = Mang->getSymbol(GV);
Chad Rosier348d5422011-06-10 00:53:15 +0000273 EmitVisibility(GVSym, GV->getVisibility(), !GV->isDeclaration());
Chris Lattner74bfe212010-01-19 05:38:33 +0000274
Rafael Espindola84397472011-04-05 15:51:32 +0000275 if (!GV->hasInitializer()) // External globals require no extra code.
276 return;
277
Chris Lattnera800f7c2010-01-25 18:33:40 +0000278 if (MAI->hasDotTypeDotSizeDirective())
279 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject);
Jim Grosbach83d80832011-03-29 23:20:22 +0000280
Chris Lattner74bfe212010-01-19 05:38:33 +0000281 SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
282
Micah Villmow3574eca2012-10-08 16:38:25 +0000283 const DataLayout *TD = TM.getDataLayout();
Chris Lattnere87f7bb2010-04-28 19:58:07 +0000284 uint64_t Size = TD->getTypeAllocSize(GV->getType()->getElementType());
Jim Grosbach83d80832011-03-29 23:20:22 +0000285
Chris Lattner567dd1f2010-04-26 18:46:46 +0000286 // If the alignment is specified, we *must* obey it. Overaligning a global
287 // with a specified alignment is a prompt way to break globals emitted to
288 // sections and expected to be contiguous (e.g. ObjC metadata).
Chris Lattnere87f7bb2010-04-28 19:58:07 +0000289 unsigned AlignLog = getGVAlignmentLog2(GV, *TD);
Jim Grosbach83d80832011-03-29 23:20:22 +0000290
Chris Lattner9744d612010-01-19 05:51:42 +0000291 // Handle common and BSS local symbols (.lcomm).
292 if (GVKind.isCommon() || GVKind.isBSSLocal()) {
Chris Lattner74bfe212010-01-19 05:38:33 +0000293 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it.
Benjamin Kramer36a16012011-09-01 23:04:27 +0000294 unsigned Align = 1 << AlignLog;
Jim Grosbach83d80832011-03-29 23:20:22 +0000295
Chris Lattner814819f2010-01-19 06:25:51 +0000296 // Handle common symbols.
Chris Lattner9744d612010-01-19 05:51:42 +0000297 if (GVKind.isCommon()) {
Chris Lattner8048ebe2010-09-27 06:44:54 +0000298 if (!getObjFileLowering().getCommDirectiveSupportsAlignment())
299 Align = 0;
Jim Grosbach83d80832011-03-29 23:20:22 +0000300
Chris Lattner9744d612010-01-19 05:51:42 +0000301 // .comm _foo, 42, 4
Chris Lattner8048ebe2010-09-27 06:44:54 +0000302 OutStreamer.EmitCommonSymbol(GVSym, Size, Align);
Chris Lattner814819f2010-01-19 06:25:51 +0000303 return;
Chris Lattner9744d612010-01-19 05:51:42 +0000304 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000305
Chris Lattner814819f2010-01-19 06:25:51 +0000306 // Handle local BSS symbols.
307 if (MAI->hasMachoZeroFillDirective()) {
308 const MCSection *TheSection =
309 getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM);
310 // .zerofill __DATA, __bss, _foo, 400, 5
Benjamin Kramer36a16012011-09-01 23:04:27 +0000311 OutStreamer.EmitZerofill(TheSection, GVSym, Size, Align);
Chris Lattner814819f2010-01-19 06:25:51 +0000312 return;
313 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000314
Benjamin Kramera9e37c52012-09-07 21:08:01 +0000315 if (Align == 1 ||
316 MAI->getLCOMMDirectiveAlignmentType() != LCOMM::NoAlignment) {
Chris Lattner814819f2010-01-19 06:25:51 +0000317 // .lcomm _foo, 42
Benjamin Kramer36a16012011-09-01 23:04:27 +0000318 OutStreamer.EmitLocalCommonSymbol(GVSym, Size, Align);
Chris Lattner814819f2010-01-19 06:25:51 +0000319 return;
320 }
Chris Lattner8048ebe2010-09-27 06:44:54 +0000321
Chris Lattner8048ebe2010-09-27 06:44:54 +0000322 if (!getObjFileLowering().getCommDirectiveSupportsAlignment())
323 Align = 0;
Jim Grosbach83d80832011-03-29 23:20:22 +0000324
Chris Lattner814819f2010-01-19 06:25:51 +0000325 // .local _foo
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000326 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local);
Chris Lattner814819f2010-01-19 06:25:51 +0000327 // .comm _foo, 42, 4
Chris Lattner8048ebe2010-09-27 06:44:54 +0000328 OutStreamer.EmitCommonSymbol(GVSym, Size, Align);
Chris Lattner74bfe212010-01-19 05:38:33 +0000329 return;
330 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000331
Chris Lattner74bfe212010-01-19 05:38:33 +0000332 const MCSection *TheSection =
333 getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM);
334
335 // Handle the zerofill directive on darwin, which is a special form of BSS
336 // emission.
337 if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) {
Chris Lattner4c4d0c02010-04-27 07:41:44 +0000338 if (Size == 0) Size = 1; // zerofill of 0 bytes is undefined.
Jim Grosbach83d80832011-03-29 23:20:22 +0000339
Chris Lattner74bfe212010-01-19 05:38:33 +0000340 // .globl _foo
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000341 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global);
Chris Lattner74bfe212010-01-19 05:38:33 +0000342 // .zerofill __DATA, __common, _foo, 400, 5
343 OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog);
344 return;
345 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000346
Eric Christopher02b46bc2010-05-25 21:28:50 +0000347 // Handle thread local data for mach-o which requires us to output an
348 // additional structure of data and mangle the original symbol so that we
349 // can reference it later.
Chris Lattnerdfe254b2010-09-05 20:33:40 +0000350 //
351 // TODO: This should become an "emit thread local global" method on TLOF.
352 // All of this macho specific stuff should be sunk down into TLOFMachO and
353 // stuff like "TLSExtraDataSection" should no longer be part of the parent
354 // TLOF class. This will also make it more obvious that stuff like
355 // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho
356 // specific code.
Eric Christopher02b46bc2010-05-25 21:28:50 +0000357 if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) {
Eric Christopher8116ca52010-05-22 00:10:22 +0000358 // Emit the .tbss symbol
Jim Grosbach83d80832011-03-29 23:20:22 +0000359 MCSymbol *MangSym =
Eric Christopher8116ca52010-05-22 00:10:22 +0000360 OutContext.GetOrCreateSymbol(GVSym->getName() + Twine("$tlv$init"));
Jim Grosbach83d80832011-03-29 23:20:22 +0000361
Eric Christopher02b46bc2010-05-25 21:28:50 +0000362 if (GVKind.isThreadBSS())
363 OutStreamer.EmitTBSSSymbol(TheSection, MangSym, Size, 1 << AlignLog);
364 else if (GVKind.isThreadData()) {
365 OutStreamer.SwitchSection(TheSection);
366
Jim Grosbach83d80832011-03-29 23:20:22 +0000367 EmitAlignment(AlignLog, GV);
Eric Christopher02b46bc2010-05-25 21:28:50 +0000368 OutStreamer.EmitLabel(MangSym);
Jim Grosbach83d80832011-03-29 23:20:22 +0000369
Eric Christopher02b46bc2010-05-25 21:28:50 +0000370 EmitGlobalConstant(GV->getInitializer());
371 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000372
Eric Christopher8116ca52010-05-22 00:10:22 +0000373 OutStreamer.AddBlankLine();
Jim Grosbach83d80832011-03-29 23:20:22 +0000374
Eric Christopher8116ca52010-05-22 00:10:22 +0000375 // Emit the variable struct for the runtime.
Jim Grosbach83d80832011-03-29 23:20:22 +0000376 const MCSection *TLVSect
Eric Christopher8116ca52010-05-22 00:10:22 +0000377 = getObjFileLowering().getTLSExtraDataSection();
Jim Grosbach83d80832011-03-29 23:20:22 +0000378
Eric Christopher8116ca52010-05-22 00:10:22 +0000379 OutStreamer.SwitchSection(TLVSect);
380 // Emit the linkage here.
381 EmitLinkage(GV->getLinkage(), GVSym);
382 OutStreamer.EmitLabel(GVSym);
Jim Grosbach83d80832011-03-29 23:20:22 +0000383
Eric Christopher8116ca52010-05-22 00:10:22 +0000384 // Three pointers in size:
385 // - __tlv_bootstrap - used to make sure support exists
386 // - spare pointer, used when mapped by the runtime
387 // - pointer to mangled symbol above with initializer
Micah Villmow2c39b152012-10-15 16:24:29 +0000388 unsigned AS = GV->getType()->getAddressSpace();
389 unsigned PtrSize = TD->getPointerSizeInBits(AS)/8;
Eric Christopher73100642010-06-03 04:02:59 +0000390 OutStreamer.EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"),
Eric Christopher8116ca52010-05-22 00:10:22 +0000391 PtrSize, 0);
392 OutStreamer.EmitIntValue(0, PtrSize, 0);
393 OutStreamer.EmitSymbolValue(MangSym, PtrSize, 0);
Jim Grosbach83d80832011-03-29 23:20:22 +0000394
Eric Christopher8116ca52010-05-22 00:10:22 +0000395 OutStreamer.AddBlankLine();
Eric Christopherc1a887d2010-05-20 00:49:07 +0000396 return;
397 }
Chris Lattner74bfe212010-01-19 05:38:33 +0000398
399 OutStreamer.SwitchSection(TheSection);
400
Chris Lattnera3e88832010-01-26 23:47:12 +0000401 EmitLinkage(GV->getLinkage(), GVSym);
Chris Lattnerf74e25f2010-04-26 18:30:45 +0000402 EmitAlignment(AlignLog, GV);
Chris Lattnera3e88832010-01-26 23:47:12 +0000403
Chris Lattner4c8c6682010-01-19 06:41:24 +0000404 OutStreamer.EmitLabel(GVSym);
Chris Lattner74bfe212010-01-19 05:38:33 +0000405
406 EmitGlobalConstant(GV->getInitializer());
407
408 if (MAI->hasDotTypeDotSizeDirective())
Chris Lattner1947f242010-01-25 07:53:05 +0000409 // .size foo, 42
Chris Lattner99328ad2010-01-25 07:52:13 +0000410 OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext));
Jim Grosbach83d80832011-03-29 23:20:22 +0000411
Chris Lattner0fd90fd2010-01-22 19:52:01 +0000412 OutStreamer.AddBlankLine();
Chris Lattner48d64ba2010-01-19 04:39:15 +0000413}
414
Chris Lattnerb11caed2010-01-26 23:18:44 +0000415/// EmitFunctionHeader - This method emits the header for the current
416/// function.
417void AsmPrinter::EmitFunctionHeader() {
418 // Print out constants referenced by the function
Chris Lattnera2406192010-01-28 00:19:24 +0000419 EmitConstantPool();
Jim Grosbach83d80832011-03-29 23:20:22 +0000420
Chris Lattnerb11caed2010-01-26 23:18:44 +0000421 // Print the 'header' of function.
Chris Lattnerb11caed2010-01-26 23:18:44 +0000422 const Function *F = MF->getFunction();
423
424 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM));
Chris Lattnerbe9dfce2010-01-28 00:05:10 +0000425 EmitVisibility(CurrentFnSym, F->getVisibility());
Chris Lattnerb11caed2010-01-26 23:18:44 +0000426
Chris Lattner111a3192010-01-26 23:51:52 +0000427 EmitLinkage(F->getLinkage(), CurrentFnSym);
Chris Lattnerb406a812010-01-26 23:41:48 +0000428 EmitAlignment(MF->getAlignment(), F);
429
Chris Lattnerb11caed2010-01-26 23:18:44 +0000430 if (MAI->hasDotTypeDotSizeDirective())
431 OutStreamer.EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
432
Chris Lattner3f53c832010-04-04 18:52:31 +0000433 if (isVerbose()) {
Chris Lattner9bc20ab2010-01-26 23:53:39 +0000434 WriteAsOperand(OutStreamer.GetCommentOS(), F,
435 /*PrintType=*/false, F->getParent());
436 OutStreamer.GetCommentOS() << '\n';
Chris Lattnerb11caed2010-01-26 23:18:44 +0000437 }
Chris Lattnerb11caed2010-01-26 23:18:44 +0000438
Dan Gohmanf451cb82010-02-10 16:03:48 +0000439 // Emit the CurrentFnSym. This is a virtual function to allow targets to
Chris Lattner2cf72512010-01-27 07:21:55 +0000440 // do their wild and crazy things as required.
441 EmitFunctionEntryLabel();
Jim Grosbach83d80832011-03-29 23:20:22 +0000442
Chris Lattner9cc0da92010-03-15 20:39:00 +0000443 // If the function had address-taken blocks that got deleted, then we have
444 // references to the dangling symbols. Emit them at the start of the function
445 // so that we don't get references to undefined symbols.
446 std::vector<MCSymbol*> DeadBlockSyms;
447 MMI->takeDeletedSymbolsForFunction(F, DeadBlockSyms);
448 for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) {
449 OutStreamer.AddComment("Address taken block that was later removed");
450 OutStreamer.EmitLabel(DeadBlockSyms[i]);
451 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000452
Chris Lattnerb11caed2010-01-26 23:18:44 +0000453 // Add some workaround for linkonce linkage on Cygwin\MinGW.
454 if (MAI->getLinkOnceDirective() != 0 &&
Chris Lattnerfd60b8b2010-04-03 22:19:41 +0000455 (F->hasLinkOnceLinkage() || F->hasWeakLinkage())) {
Chris Lattner9bc20ab2010-01-26 23:53:39 +0000456 // FIXME: What is this?
Jim Grosbach83d80832011-03-29 23:20:22 +0000457 MCSymbol *FakeStub =
Chris Lattnerfd60b8b2010-04-03 22:19:41 +0000458 OutContext.GetOrCreateSymbol(Twine("Lllvm$workaround$fake$stub$")+
459 CurrentFnSym->getName());
460 OutStreamer.EmitLabel(FakeStub);
461 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000462
Chris Lattnerb11caed2010-01-26 23:18:44 +0000463 // Emit pre-function debug and/or EH information.
Torok Edwin9c421072010-04-07 10:44:46 +0000464 if (DE) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000465 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
466 DE->BeginFunction(MF);
Torok Edwin9c421072010-04-07 10:44:46 +0000467 }
468 if (DD) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000469 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
470 DD->beginFunction(MF);
Torok Edwin9c421072010-04-07 10:44:46 +0000471 }
Chris Lattnerb11caed2010-01-26 23:18:44 +0000472}
473
Chris Lattner2cf72512010-01-27 07:21:55 +0000474/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the
475/// function. This can be overridden by targets as required to do custom stuff.
476void AsmPrinter::EmitFunctionEntryLabel() {
Chris Lattnerb4202db2010-05-06 00:05:37 +0000477 // The function label could have already been emitted if two symbols end up
478 // conflicting due to asm renaming. Detect this and emit an error.
Jim Grosbach3e965312012-05-18 19:12:01 +0000479 if (CurrentFnSym->isUndefined())
Chris Lattnerb4202db2010-05-06 00:05:37 +0000480 return OutStreamer.EmitLabel(CurrentFnSym);
481
482 report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
483 "' label emitted multiple times to assembly file");
Chris Lattner2cf72512010-01-27 07:21:55 +0000484}
Chris Lattnerb11caed2010-01-26 23:18:44 +0000485
Chad Rosierc53ade22012-09-07 18:16:38 +0000486/// emitComments - Pretty-print comments for instructions.
487static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
Devang Patele025e962010-06-29 22:29:15 +0000488 const MachineFunction *MF = MI.getParent()->getParent();
489 const TargetMachine &TM = MF->getTarget();
Jim Grosbach83d80832011-03-29 23:20:22 +0000490
Chris Lattner47529c92010-02-10 00:47:53 +0000491 // Check for spills and reloads
492 int FI;
Jim Grosbach83d80832011-03-29 23:20:22 +0000493
Chris Lattner47529c92010-02-10 00:47:53 +0000494 const MachineFrameInfo *FrameInfo = MF->getFrameInfo();
Jim Grosbach83d80832011-03-29 23:20:22 +0000495
Chris Lattner47529c92010-02-10 00:47:53 +0000496 // We assume a single instruction only has a spill or reload, not
497 // both.
498 const MachineMemOperand *MMO;
499 if (TM.getInstrInfo()->isLoadFromStackSlotPostFE(&MI, FI)) {
500 if (FrameInfo->isSpillSlotObjectIndex(FI)) {
501 MMO = *MI.memoperands_begin();
502 CommentOS << MMO->getSize() << "-byte Reload\n";
503 }
504 } else if (TM.getInstrInfo()->hasLoadFromStackSlot(&MI, MMO, FI)) {
505 if (FrameInfo->isSpillSlotObjectIndex(FI))
506 CommentOS << MMO->getSize() << "-byte Folded Reload\n";
507 } else if (TM.getInstrInfo()->isStoreToStackSlotPostFE(&MI, FI)) {
508 if (FrameInfo->isSpillSlotObjectIndex(FI)) {
509 MMO = *MI.memoperands_begin();
510 CommentOS << MMO->getSize() << "-byte Spill\n";
511 }
512 } else if (TM.getInstrInfo()->hasStoreToStackSlot(&MI, MMO, FI)) {
513 if (FrameInfo->isSpillSlotObjectIndex(FI))
514 CommentOS << MMO->getSize() << "-byte Folded Spill\n";
515 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000516
Chris Lattner47529c92010-02-10 00:47:53 +0000517 // Check for spill-induced copies
Jakob Stoklund Olesen04c528a2010-07-16 04:45:42 +0000518 if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse))
519 CommentOS << " Reload Reuse\n";
Chris Lattner47529c92010-02-10 00:47:53 +0000520}
521
Chad Rosierc53ade22012-09-07 18:16:38 +0000522/// emitImplicitDef - This method emits the specified machine instruction
Chris Lattner17fedf22010-04-04 18:58:53 +0000523/// that is an implicit def.
Chad Rosierc53ade22012-09-07 18:16:38 +0000524static void emitImplicitDef(const MachineInstr *MI, AsmPrinter &AP) {
Chris Lattner17fedf22010-04-04 18:58:53 +0000525 unsigned RegNo = MI->getOperand(0).getReg();
526 AP.OutStreamer.AddComment(Twine("implicit-def: ") +
527 AP.TM.getRegisterInfo()->getName(RegNo));
528 AP.OutStreamer.AddBlankLine();
529}
530
Chad Rosierc53ade22012-09-07 18:16:38 +0000531static void emitKill(const MachineInstr *MI, AsmPrinter &AP) {
Chris Lattner17fedf22010-04-04 18:58:53 +0000532 std::string Str = "kill:";
533 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
534 const MachineOperand &Op = MI->getOperand(i);
535 assert(Op.isReg() && "KILL instruction must have only register operands");
536 Str += ' ';
537 Str += AP.TM.getRegisterInfo()->getName(Op.getReg());
538 Str += (Op.isDef() ? "<def>" : "<kill>");
539 }
540 AP.OutStreamer.AddComment(Str);
541 AP.OutStreamer.AddBlankLine();
542}
543
Chad Rosierc53ade22012-09-07 18:16:38 +0000544/// emitDebugValueComment - This method handles the target-independent form
Dale Johannesen343b42e2010-04-07 01:15:14 +0000545/// of DBG_VALUE, returning true if it was able to do so. A false return
546/// means the target will need to handle MI in EmitInstruction.
Chad Rosierc53ade22012-09-07 18:16:38 +0000547static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
Dale Johannesen343b42e2010-04-07 01:15:14 +0000548 // This code handles only the 3-operand target-independent form.
549 if (MI->getNumOperands() != 3)
550 return false;
Chris Lattner47529c92010-02-10 00:47:53 +0000551
Benjamin Kramera592e672010-04-07 09:26:51 +0000552 SmallString<128> Str;
553 raw_svector_ostream OS(Str);
554 OS << '\t' << AP.MAI->getCommentString() << "DEBUG_VALUE: ";
555
Dale Johannesen343b42e2010-04-07 01:15:14 +0000556 // cast away const; DIetc do not take const operands for some reason.
Chris Lattner00d13902010-04-07 22:29:10 +0000557 DIVariable V(const_cast<MDNode*>(MI->getOperand(2).getMetadata()));
Devang Patel67a444c2010-04-29 18:52:10 +0000558 if (V.getContext().isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +0000559 OS << DISubprogram(V.getContext()).getDisplayName() << ":";
Benjamin Kramera592e672010-04-07 09:26:51 +0000560 OS << V.getName() << " <- ";
Dale Johannesen343b42e2010-04-07 01:15:14 +0000561
562 // Register or immediate value. Register 0 means undef.
563 if (MI->getOperand(0).isFPImm()) {
564 APFloat APF = APFloat(MI->getOperand(0).getFPImm()->getValueAPF());
565 if (MI->getOperand(0).getFPImm()->getType()->isFloatTy()) {
Benjamin Kramera592e672010-04-07 09:26:51 +0000566 OS << (double)APF.convertToFloat();
Dale Johannesen343b42e2010-04-07 01:15:14 +0000567 } else if (MI->getOperand(0).getFPImm()->getType()->isDoubleTy()) {
Benjamin Kramera592e672010-04-07 09:26:51 +0000568 OS << APF.convertToDouble();
Dale Johannesen343b42e2010-04-07 01:15:14 +0000569 } else {
570 // There is no good way to print long double. Convert a copy to
571 // double. Ah well, it's only a comment.
572 bool ignored;
573 APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
574 &ignored);
Benjamin Kramera592e672010-04-07 09:26:51 +0000575 OS << "(long double) " << APF.convertToDouble();
Dale Johannesen343b42e2010-04-07 01:15:14 +0000576 }
577 } else if (MI->getOperand(0).isImm()) {
Benjamin Kramera592e672010-04-07 09:26:51 +0000578 OS << MI->getOperand(0).getImm();
Devang Patel8594d422011-06-24 20:46:11 +0000579 } else if (MI->getOperand(0).isCImm()) {
580 MI->getOperand(0).getCImm()->getValue().print(OS, false /*isSigned*/);
Chris Lattner00d13902010-04-07 22:29:10 +0000581 } else {
582 assert(MI->getOperand(0).isReg() && "Unknown operand type");
Dale Johannesen343b42e2010-04-07 01:15:14 +0000583 if (MI->getOperand(0).getReg() == 0) {
584 // Suppress offset, it is not meaningful here.
Benjamin Kramera592e672010-04-07 09:26:51 +0000585 OS << "undef";
Dale Johannesen343b42e2010-04-07 01:15:14 +0000586 // NOTE: Want this comment at start of line, don't emit with AddComment.
Benjamin Kramera592e672010-04-07 09:26:51 +0000587 AP.OutStreamer.EmitRawText(OS.str());
Dale Johannesen343b42e2010-04-07 01:15:14 +0000588 return true;
589 }
Benjamin Kramera592e672010-04-07 09:26:51 +0000590 OS << AP.TM.getRegisterInfo()->getName(MI->getOperand(0).getReg());
Chris Lattner00d13902010-04-07 22:29:10 +0000591 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000592
Benjamin Kramera592e672010-04-07 09:26:51 +0000593 OS << '+' << MI->getOperand(1).getImm();
Dale Johannesen343b42e2010-04-07 01:15:14 +0000594 // NOTE: Want this comment at start of line, don't emit with AddComment.
Benjamin Kramera592e672010-04-07 09:26:51 +0000595 AP.OutStreamer.EmitRawText(OS.str());
Dale Johannesen343b42e2010-04-07 01:15:14 +0000596 return true;
597}
Chris Lattner47529c92010-02-10 00:47:53 +0000598
Rafael Espindolae29887b2011-05-10 18:39:09 +0000599AsmPrinter::CFIMoveType AsmPrinter::needsCFIMoves() {
Rafael Espindolafc2bb8c2011-05-25 03:44:17 +0000600 if (MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI &&
601 MF->getFunction()->needsUnwindTableEntry())
602 return CFI_M_EH;
Rafael Espindolaa4329972011-04-29 14:14:06 +0000603
Rafael Espindolaf2b04232011-05-06 14:56:22 +0000604 if (MMI->hasDebugInfo())
Rafael Espindolae29887b2011-05-10 18:39:09 +0000605 return CFI_M_Debug;
Rafael Espindolaa4329972011-04-29 14:14:06 +0000606
Rafael Espindolae29887b2011-05-10 18:39:09 +0000607 return CFI_M_None;
Rafael Espindolaa4329972011-04-29 14:14:06 +0000608}
609
Charles Davisf4633702011-05-28 04:21:04 +0000610bool AsmPrinter::needsSEHMoves() {
611 return MAI->getExceptionHandlingType() == ExceptionHandling::Win64 &&
612 MF->getFunction()->needsUnwindTableEntry();
613}
614
Nick Lewycky390c40d2011-10-27 06:44:11 +0000615bool AsmPrinter::needsRelocationsForDwarfStringPool() const {
Rafael Espindola9cfc7992012-06-22 13:32:49 +0000616 return MAI->doesDwarfUseRelocationsAcrossSections();
Nick Lewycky390c40d2011-10-27 06:44:11 +0000617}
618
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000619void AsmPrinter::emitPrologLabel(const MachineInstr &MI) {
620 MCSymbol *Label = MI.getOperand(0).getMCSymbol();
Rafael Espindolafea8fea2011-04-26 19:26:53 +0000621
Rafael Espindolaf2b04232011-05-06 14:56:22 +0000622 if (MAI->getExceptionHandlingType() != ExceptionHandling::DwarfCFI)
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000623 return;
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000624
Rafael Espindolae29887b2011-05-10 18:39:09 +0000625 if (needsCFIMoves() == CFI_M_None)
Rafael Espindolaa4329972011-04-29 14:14:06 +0000626 return;
627
Bill Wendlinge060a5c2011-07-19 00:02:51 +0000628 if (MMI->getCompactUnwindEncoding() != 0)
629 OutStreamer.EmitCompactUnwindEncoding(MMI->getCompactUnwindEncoding());
630
Rafael Espindolaa4329972011-04-29 14:14:06 +0000631 MachineModuleInfo &MMI = MF->getMMI();
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000632 std::vector<MachineMove> &Moves = MMI.getFrameMoves();
Rafael Espindolab28d4f12011-04-26 03:58:56 +0000633 bool FoundOne = false;
634 (void)FoundOne;
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000635 for (std::vector<MachineMove>::iterator I = Moves.begin(),
636 E = Moves.end(); I != E; ++I) {
637 if (I->getLabel() == Label) {
Rafael Espindolab28d4f12011-04-26 03:58:56 +0000638 EmitCFIFrameMove(*I);
639 FoundOne = true;
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000640 }
641 }
Rafael Espindolab28d4f12011-04-26 03:58:56 +0000642 assert(FoundOne);
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000643}
644
Chris Lattner14c38ec2010-01-28 01:02:27 +0000645/// EmitFunctionBody - This method emits the body and trailer for a
646/// function.
647void AsmPrinter::EmitFunctionBody() {
Chris Lattneredfe7762010-01-28 01:58:58 +0000648 // Emit target-specific gunk before the function body.
649 EmitFunctionBodyStart();
Jim Grosbach83d80832011-03-29 23:20:22 +0000650
Chris Lattner49cd6642010-04-05 05:11:15 +0000651 bool ShouldPrintDebugScopes = DD && MMI->hasDebugInfo();
Jim Grosbach83d80832011-03-29 23:20:22 +0000652
Chris Lattner14c38ec2010-01-28 01:02:27 +0000653 // Print out code for the function.
654 bool HasAnyRealCode = false;
Bill Wendlingdc867042010-07-16 22:51:10 +0000655 const MachineInstr *LastMI = 0;
Chris Lattner14c38ec2010-01-28 01:02:27 +0000656 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
657 I != E; ++I) {
658 // Print a label for the basic block.
659 EmitBasicBlockStart(I);
660 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
661 II != IE; ++II) {
Bill Wendlingdc867042010-07-16 22:51:10 +0000662 LastMI = II;
663
Chris Lattner14c38ec2010-01-28 01:02:27 +0000664 // Print the assembly for the instruction.
Dale Johannesend0147612010-05-01 16:41:11 +0000665 if (!II->isLabel() && !II->isImplicitDef() && !II->isKill() &&
666 !II->isDebugValue()) {
Chris Lattner14c38ec2010-01-28 01:02:27 +0000667 HasAnyRealCode = true;
Evan Chenged33b132010-04-27 19:38:45 +0000668 ++EmittedInsts;
669 }
670
Torok Edwin9c421072010-04-07 10:44:46 +0000671 if (ShouldPrintDebugScopes) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000672 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Devang Patelcbbe2872010-10-26 17:49:02 +0000673 DD->beginInstruction(II);
Torok Edwin9c421072010-04-07 10:44:46 +0000674 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000675
Chris Lattner3f53c832010-04-04 18:52:31 +0000676 if (isVerbose())
Chad Rosierc53ade22012-09-07 18:16:38 +0000677 emitComments(*II, OutStreamer.GetCommentOS());
Chris Lattner47529c92010-02-10 00:47:53 +0000678
Chris Lattner0d883e32010-02-03 01:00:52 +0000679 switch (II->getOpcode()) {
Bill Wendling7431bea2010-07-16 22:20:36 +0000680 case TargetOpcode::PROLOG_LABEL:
Rafael Espindolaf0adba92011-04-15 15:11:06 +0000681 emitPrologLabel(*II);
682 break;
683
Chris Lattner518bb532010-02-09 19:54:29 +0000684 case TargetOpcode::EH_LABEL:
685 case TargetOpcode::GC_LABEL:
Chris Lattner300a4c52010-04-04 18:14:01 +0000686 OutStreamer.EmitLabel(II->getOperand(0).getMCSymbol());
Chris Lattner0d883e32010-02-03 01:00:52 +0000687 break;
Chris Lattner518bb532010-02-09 19:54:29 +0000688 case TargetOpcode::INLINEASM:
Chris Lattner300a4c52010-04-04 18:14:01 +0000689 EmitInlineAsm(II);
Chris Lattner0d883e32010-02-03 01:00:52 +0000690 break;
Dale Johannesen343b42e2010-04-07 01:15:14 +0000691 case TargetOpcode::DBG_VALUE:
692 if (isVerbose()) {
Chad Rosierc53ade22012-09-07 18:16:38 +0000693 if (!emitDebugValueComment(II, *this))
Dale Johannesen343b42e2010-04-07 01:15:14 +0000694 EmitInstruction(II);
695 }
696 break;
Chris Lattner518bb532010-02-09 19:54:29 +0000697 case TargetOpcode::IMPLICIT_DEF:
Chad Rosierc53ade22012-09-07 18:16:38 +0000698 if (isVerbose()) emitImplicitDef(II, *this);
Chris Lattner0d883e32010-02-03 01:00:52 +0000699 break;
Chris Lattner518bb532010-02-09 19:54:29 +0000700 case TargetOpcode::KILL:
Chad Rosierc53ade22012-09-07 18:16:38 +0000701 if (isVerbose()) emitKill(II, *this);
Chris Lattner0d883e32010-02-03 01:00:52 +0000702 break;
703 default:
Devang Patel49a3ff92011-04-29 18:00:54 +0000704 if (!TM.hasMCUseLoc())
705 MCLineEntry::Make(&OutStreamer, getCurrentSection());
706
Chris Lattner0d883e32010-02-03 01:00:52 +0000707 EmitInstruction(II);
708 break;
709 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000710
Torok Edwin9c421072010-04-07 10:44:46 +0000711 if (ShouldPrintDebugScopes) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000712 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Devang Patelcbbe2872010-10-26 17:49:02 +0000713 DD->endInstruction(II);
Torok Edwin9c421072010-04-07 10:44:46 +0000714 }
Chris Lattner14c38ec2010-01-28 01:02:27 +0000715 }
716 }
Bill Wendlingdc867042010-07-16 22:51:10 +0000717
718 // If the last instruction was a prolog label, then we have a situation where
719 // we emitted a prolog but no function body. This results in the ending prolog
720 // label equaling the end of function label and an invalid "row" in the
721 // FDE. We need to emit a noop in this situation so that the FDE's rows are
722 // valid.
Bill Wendling74908962010-07-17 19:18:44 +0000723 bool RequiresNoop = LastMI && LastMI->isPrologLabel();
Bill Wendlingdc867042010-07-16 22:51:10 +0000724
Chris Lattner14c38ec2010-01-28 01:02:27 +0000725 // If the function is empty and the object file uses .subsections_via_symbols,
Chris Lattnerd49fe1b2010-01-28 01:28:58 +0000726 // then we need to emit *something* to the function body to prevent the
Chris Lattneree9eb412010-04-26 23:37:21 +0000727 // labels from collapsing together. Just emit a noop.
Bill Wendlingdc867042010-07-16 22:51:10 +0000728 if ((MAI->hasSubsectionsViaSymbols() && !HasAnyRealCode) || RequiresNoop) {
Chris Lattneree9eb412010-04-26 23:37:21 +0000729 MCInst Noop;
730 TM.getInstrInfo()->getNoopForMachoTarget(Noop);
Chris Lattnerd61647d2010-04-26 23:41:43 +0000731 if (Noop.getOpcode()) {
732 OutStreamer.AddComment("avoids zero-length function");
Chris Lattneree9eb412010-04-26 23:37:21 +0000733 OutStreamer.EmitInstruction(Noop);
Chris Lattnerd61647d2010-04-26 23:41:43 +0000734 } else // Target not mc-ized yet.
Chris Lattneree9eb412010-04-26 23:37:21 +0000735 OutStreamer.EmitRawText(StringRef("\tnop\n"));
736 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000737
Rafael Espindola6c5b2dc2011-11-15 19:08:46 +0000738 const Function *F = MF->getFunction();
739 for (Function::const_iterator i = F->begin(), e = F->end(); i != e; ++i) {
740 const BasicBlock *BB = i;
741 if (!BB->hasAddressTaken())
742 continue;
743 MCSymbol *Sym = GetBlockAddressSymbol(BB);
744 if (Sym->isDefined())
745 continue;
746 OutStreamer.AddComment("Address of block that was removed by CodeGen");
747 OutStreamer.EmitLabel(Sym);
748 }
749
Chris Lattneredfe7762010-01-28 01:58:58 +0000750 // Emit target-specific gunk after the function body.
751 EmitFunctionBodyEnd();
Jim Grosbach83d80832011-03-29 23:20:22 +0000752
Chris Lattnerfd60b8b2010-04-03 22:19:41 +0000753 // If the target wants a .size directive for the size of the function, emit
754 // it.
755 if (MAI->hasDotTypeDotSizeDirective()) {
Chris Lattner0c08d092010-04-03 22:28:33 +0000756 // Create a symbol for the end of function, so we can get the size as
757 // difference between the function label and the temp label.
758 MCSymbol *FnEndLabel = OutContext.CreateTempSymbol();
759 OutStreamer.EmitLabel(FnEndLabel);
Jim Grosbach83d80832011-03-29 23:20:22 +0000760
Chris Lattner0c08d092010-04-03 22:28:33 +0000761 const MCExpr *SizeExp =
762 MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(FnEndLabel, OutContext),
Hal Finkeld55a2662012-02-22 21:11:47 +0000763 MCSymbolRefExpr::Create(CurrentFnSymForSize,
764 OutContext),
Chris Lattner0c08d092010-04-03 22:28:33 +0000765 OutContext);
766 OutStreamer.EmitELFSize(CurrentFnSym, SizeExp);
Chris Lattnerfd60b8b2010-04-03 22:19:41 +0000767 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000768
Chris Lattner14c38ec2010-01-28 01:02:27 +0000769 // Emit post-function debug information.
Torok Edwin9c421072010-04-07 10:44:46 +0000770 if (DD) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000771 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
772 DD->endFunction(MF);
Torok Edwin9c421072010-04-07 10:44:46 +0000773 }
774 if (DE) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000775 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
776 DE->EndFunction();
Torok Edwin9c421072010-04-07 10:44:46 +0000777 }
Chris Lattner49cd6642010-04-05 05:11:15 +0000778 MMI->EndFunction();
Jim Grosbach83d80832011-03-29 23:20:22 +0000779
Chris Lattner14c38ec2010-01-28 01:02:27 +0000780 // Print out jump tables referenced by the function.
781 EmitJumpTableInfo();
Jim Grosbach83d80832011-03-29 23:20:22 +0000782
Chris Lattnerd26a80f2010-02-03 01:49:49 +0000783 OutStreamer.AddBlankLine();
Chris Lattner14c38ec2010-01-28 01:02:27 +0000784}
785
Devang Patel28ff35d2010-04-28 01:39:28 +0000786/// getDebugValueLocation - Get location information encoded by DBG_VALUE
787/// operands.
Jim Grosbach83d80832011-03-29 23:20:22 +0000788MachineLocation AsmPrinter::
789getDebugValueLocation(const MachineInstr *MI) const {
Devang Patel28ff35d2010-04-28 01:39:28 +0000790 // Target specific DBG_VALUE instructions are handled by each target.
791 return MachineLocation();
792}
Chris Lattner14c38ec2010-01-28 01:02:27 +0000793
Devang Patelacc381b2011-04-21 21:07:35 +0000794/// EmitDwarfRegOp - Emit dwarf register operation.
Devang Patel0be77df2011-04-27 20:29:27 +0000795void AsmPrinter::EmitDwarfRegOp(const MachineLocation &MLoc) const {
Devang Patelc26f5442011-04-28 02:22:40 +0000796 const TargetRegisterInfo *TRI = TM.getRegisterInfo();
Rafael Espindola37afca12011-05-27 22:15:01 +0000797 int Reg = TRI->getDwarfRegNum(MLoc.getReg(), false);
798
Jakob Stoklund Olesen396618b2012-06-01 23:28:30 +0000799 for (MCSuperRegIterator SR(MLoc.getReg(), TRI); SR.isValid() && Reg < 0;
800 ++SR) {
Rafael Espindola37afca12011-05-27 22:15:01 +0000801 Reg = TRI->getDwarfRegNum(*SR, false);
802 // FIXME: Get the bit range this register uses of the superregister
803 // so that we can produce a DW_OP_bit_piece
804 }
805
806 // FIXME: Handle cases like a super register being encoded as
807 // DW_OP_reg 32 DW_OP_piece 4 DW_OP_reg 33
808
809 // FIXME: We have no reasonable way of handling errors in here. The
810 // caller might be in the middle of an dwarf expression. We should
811 // probably assert that Reg >= 0 once debug info generation is more mature.
812
Devang Patelacc381b2011-04-21 21:07:35 +0000813 if (int Offset = MLoc.getOffset()) {
Devang Patelc26f5442011-04-28 02:22:40 +0000814 if (Reg < 32) {
815 OutStreamer.AddComment(
816 dwarf::OperationEncodingString(dwarf::DW_OP_breg0 + Reg));
817 EmitInt8(dwarf::DW_OP_breg0 + Reg);
818 } else {
819 OutStreamer.AddComment("DW_OP_bregx");
820 EmitInt8(dwarf::DW_OP_bregx);
821 OutStreamer.AddComment(Twine(Reg));
822 EmitULEB128(Reg);
823 }
Devang Patelacc381b2011-04-21 21:07:35 +0000824 EmitSLEB128(Offset);
825 } else {
826 if (Reg < 32) {
Devang Patelacc381b2011-04-21 21:07:35 +0000827 OutStreamer.AddComment(
828 dwarf::OperationEncodingString(dwarf::DW_OP_reg0 + Reg));
829 EmitInt8(dwarf::DW_OP_reg0 + Reg);
830 } else {
Devang Patelc26f5442011-04-28 02:22:40 +0000831 OutStreamer.AddComment("DW_OP_regx");
Devang Patelacc381b2011-04-21 21:07:35 +0000832 EmitInt8(dwarf::DW_OP_regx);
833 OutStreamer.AddComment(Twine(Reg));
834 EmitULEB128(Reg);
835 }
836 }
Rafael Espindola37afca12011-05-27 22:15:01 +0000837
838 // FIXME: Produce a DW_OP_bit_piece if we used a superregister
Devang Patelacc381b2011-04-21 21:07:35 +0000839}
840
Chris Lattnera80ba712004-08-16 23:15:22 +0000841bool AsmPrinter::doFinalization(Module &M) {
Chris Lattner40bbebd2009-07-21 18:38:57 +0000842 // Emit global variables.
843 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
844 I != E; ++I)
Chris Lattner48d64ba2010-01-19 04:39:15 +0000845 EmitGlobalVariable(I);
Rafael Espindola1ffb5332011-01-28 03:20:10 +0000846
847 // Emit visibility info for declarations
848 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) {
849 const Function &F = *I;
850 if (!F.isDeclaration())
851 continue;
852 GlobalValue::VisibilityTypes V = F.getVisibility();
853 if (V == GlobalValue::DefaultVisibility)
854 continue;
855
856 MCSymbol *Name = Mang->getSymbol(&F);
Stuart Hastings5129bde2011-02-23 02:27:05 +0000857 EmitVisibility(Name, V, false);
Rafael Espindola1ffb5332011-01-28 03:20:10 +0000858 }
859
Bill Wendlingb464d3f2012-02-14 21:28:13 +0000860 // Emit module flags.
Bill Wendling057d5212012-02-15 22:36:15 +0000861 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
862 M.getModuleFlagsMetadata(ModuleFlags);
863 if (!ModuleFlags.empty())
864 getObjFileLowering().emitModuleFlags(OutStreamer, ModuleFlags, Mang, TM);
Bill Wendlingb464d3f2012-02-14 21:28:13 +0000865
Chris Lattner49cd6642010-04-05 05:11:15 +0000866 // Finalize debug and EH information.
867 if (DE) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000868 {
869 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
Torok Edwin9c421072010-04-07 10:44:46 +0000870 DE->EndModule();
871 }
Chris Lattner49cd6642010-04-05 05:11:15 +0000872 delete DE; DE = 0;
873 }
874 if (DD) {
Dan Gohman03c3dc72010-06-18 15:56:31 +0000875 {
876 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
Torok Edwin9c421072010-04-07 10:44:46 +0000877 DD->endModule();
878 }
Chris Lattner49cd6642010-04-05 05:11:15 +0000879 delete DD; DD = 0;
880 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000881
Chris Lattner0a7befa2009-06-24 18:52:01 +0000882 // If the target wants to know about weak references, print them all.
Chris Lattner33adcfb2009-08-22 21:43:10 +0000883 if (MAI->getWeakRefDirective()) {
Chris Lattner0a7befa2009-06-24 18:52:01 +0000884 // FIXME: This is not lazy, it would be nice to only print weak references
885 // to stuff that is actually used. Note that doing so would require targets
886 // to notice uses in operands (due to constant exprs etc). This should
887 // happen with the MC stuff eventually.
Rafael Espindola15404d02006-12-18 03:37:18 +0000888
Chris Lattner0a7befa2009-06-24 18:52:01 +0000889 // Print out module-level global variables here.
890 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
891 I != E; ++I) {
Chris Lattner08ce3b42010-01-16 18:17:26 +0000892 if (!I->hasExternalWeakLinkage()) continue;
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000893 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(I), MCSA_WeakReference);
Chris Lattner0a7befa2009-06-24 18:52:01 +0000894 }
Jim Grosbach83d80832011-03-29 23:20:22 +0000895
Chris Lattnerc6fdced2009-08-03 23:10:34 +0000896 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) {
Chris Lattner08ce3b42010-01-16 18:17:26 +0000897 if (!I->hasExternalWeakLinkage()) continue;
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000898 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(I), MCSA_WeakReference);
Chris Lattner0a7befa2009-06-24 18:52:01 +0000899 }
Rafael Espindola15404d02006-12-18 03:37:18 +0000900 }
901
Chris Lattnercee63322010-01-26 20:40:54 +0000902 if (MAI->hasSetDirective()) {
Chris Lattner3a9be0e2010-01-23 05:51:36 +0000903 OutStreamer.AddBlankLine();
Anton Korobeynikov8b0a8c82007-04-25 14:27:10 +0000904 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
Chris Lattner0a7befa2009-06-24 18:52:01 +0000905 I != E; ++I) {
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000906 MCSymbol *Name = Mang->getSymbol(I);
Anton Korobeynikov325be7c2007-09-06 17:21:48 +0000907
Jay Foadb899d952011-08-01 12:27:15 +0000908 const GlobalValue *GV = I->getAliasedGlobal();
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000909 MCSymbol *Target = Mang->getSymbol(GV);
Anton Korobeynikov541af7f2008-09-24 22:21:04 +0000910
Chris Lattner10b318b2010-01-17 21:43:43 +0000911 if (I->hasExternalLinkage() || !MAI->getWeakRefDirective())
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000912 OutStreamer.EmitSymbolAttribute(Name, MCSA_Global);
Chris Lattner10b318b2010-01-17 21:43:43 +0000913 else if (I->hasWeakLinkage())
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000914 OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference);
Chris Lattner10b318b2010-01-17 21:43:43 +0000915 else
Chris Lattner10595492010-01-16 01:37:14 +0000916 assert(I->hasLocalLinkage() && "Invalid alias linkage");
Anton Korobeynikov22c9e652008-03-11 21:41:14 +0000917
Chris Lattnerbe9dfce2010-01-28 00:05:10 +0000918 EmitVisibility(Name, I->getVisibility());
Anton Korobeynikov22c9e652008-03-11 21:41:14 +0000919
Chris Lattnerc618c8a2010-01-26 21:53:08 +0000920 // Emit the directives as assignments aka .set:
Jim Grosbach83d80832011-03-29 23:20:22 +0000921 OutStreamer.EmitAssignment(Name,
Chris Lattnerc618c8a2010-01-26 21:53:08 +0000922 MCSymbolRefExpr::Create(Target, OutContext));
Anton Korobeynikov8b0a8c82007-04-25 14:27:10 +0000923 }
924 }
925
Duncan Sands1465d612009-01-28 13:14:17 +0000926 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
Gordon Henriksen5eca0752008-08-17 18:44:35 +0000927 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
928 for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; )
929 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I))
Chris Lattner7d73c7f2010-04-04 07:39:04 +0000930 MP->finishAssembly(*this);
Gordon Henriksence224772008-01-07 01:30:38 +0000931
Dan Gohmana779a982008-05-05 00:28:39 +0000932 // If we don't have any trampolines, then we don't require stack memory
933 // to be executable. Some targets have a directive to declare this.
Chris Lattner0a7befa2009-06-24 18:52:01 +0000934 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");
Dan Gohmana779a982008-05-05 00:28:39 +0000935 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty())
Chris Lattner74aae472010-04-08 21:26:26 +0000936 if (const MCSection *S = MAI->getNonexecutableStackSection(OutContext))
Chris Lattnerf9f93e42010-01-23 07:21:06 +0000937 OutStreamer.SwitchSection(S);
Jim Grosbach83d80832011-03-29 23:20:22 +0000938
Chris Lattnerbd23d5f2009-09-18 20:17:03 +0000939 // Allow the target to emit any magic that it wants at the end of the file,
940 // after everything else has gone out.
941 EmitEndOfAsmFile(M);
Jim Grosbach83d80832011-03-29 23:20:22 +0000942
Chris Lattnera80ba712004-08-16 23:15:22 +0000943 delete Mang; Mang = 0;
Chris Lattner49cd6642010-04-05 05:11:15 +0000944 MMI = 0;
Jim Grosbach83d80832011-03-29 23:20:22 +0000945
Chris Lattner2b2954f2009-07-27 21:28:04 +0000946 OutStreamer.Finish();
Chris Lattnera80ba712004-08-16 23:15:22 +0000947 return false;
948}
949
Chris Lattner25045bd2005-11-21 07:51:36 +0000950void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
Chris Lattnerb84822f2010-01-26 04:35:26 +0000951 this->MF = &MF;
Chris Lattner412c3a52010-01-16 01:24:10 +0000952 // Get the function symbol.
Chris Lattnerdeb0cba2010-03-12 21:09:07 +0000953 CurrentFnSym = Mang->getSymbol(MF.getFunction());
Hal Finkeld55a2662012-02-22 21:11:47 +0000954 CurrentFnSymForSize = CurrentFnSym;
David Greeneb71d1b22009-08-10 16:38:07 +0000955
Chris Lattner3f53c832010-04-04 18:52:31 +0000956 if (isVerbose())
David Greeneb71d1b22009-08-10 16:38:07 +0000957 LI = &getAnalysis<MachineLoopInfo>();
Chris Lattnera80ba712004-08-16 23:15:22 +0000958}
959
Evan Cheng1606e8e2009-03-13 07:51:59 +0000960namespace {
961 // SectionCPs - Keep track the alignment, constpool entries per Section.
962 struct SectionCPs {
Chris Lattnera87dea42009-07-31 18:48:30 +0000963 const MCSection *S;
Evan Cheng1606e8e2009-03-13 07:51:59 +0000964 unsigned Alignment;
965 SmallVector<unsigned, 4> CPEs;
Douglas Gregorcabdd742009-12-19 07:05:23 +0000966 SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {}
Evan Cheng1606e8e2009-03-13 07:51:59 +0000967 };
968}
969
Chris Lattner3b4fd322005-11-21 08:25:09 +0000970/// EmitConstantPool - Print to the current output stream assembly
971/// representations of the constants in the constant pool MCP. This is
972/// used to print out constants which have been "spilled to memory" by
973/// the code generator.
974///
Chris Lattnera2406192010-01-28 00:19:24 +0000975void AsmPrinter::EmitConstantPool() {
976 const MachineConstantPool *MCP = MF->getConstantPool();
Chris Lattnerfa77d432006-02-09 04:22:52 +0000977 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
Chris Lattner3b4fd322005-11-21 08:25:09 +0000978 if (CP.empty()) return;
Evan Cheng2d2cec12006-06-29 00:26:09 +0000979
Anton Korobeynikov088ae832008-09-24 22:17:59 +0000980 // Calculate sections for constant pool entries. We collect entries to go into
981 // the same section together to reduce amount of section switch statements.
Evan Cheng1606e8e2009-03-13 07:51:59 +0000982 SmallVector<SectionCPs, 4> CPSections;
Chris Lattner3b4fd322005-11-21 08:25:09 +0000983 for (unsigned i = 0, e = CP.size(); i != e; ++i) {
Chris Lattner298414e2009-07-22 00:28:43 +0000984 const MachineConstantPoolEntry &CPE = CP[i];
Evan Cheng1606e8e2009-03-13 07:51:59 +0000985 unsigned Align = CPE.getAlignment();
Jim Grosbach83d80832011-03-29 23:20:22 +0000986
Chris Lattner5c2f7892009-07-26 06:26:55 +0000987 SectionKind Kind;
988 switch (CPE.getRelocationInfo()) {
989 default: llvm_unreachable("Unknown section kind");
Chris Lattner27981192009-08-01 23:57:16 +0000990 case 2: Kind = SectionKind::getReadOnlyWithRel(); break;
Chris Lattner4c509222009-07-26 07:00:12 +0000991 case 1:
Chris Lattner27981192009-08-01 23:57:16 +0000992 Kind = SectionKind::getReadOnlyWithRelLocal();
Chris Lattner4c509222009-07-26 07:00:12 +0000993 break;
Chris Lattner5c2f7892009-07-26 06:26:55 +0000994 case 0:
Micah Villmow3574eca2012-10-08 16:38:25 +0000995 switch (TM.getDataLayout()->getTypeAllocSize(CPE.getType())) {
Chris Lattner27981192009-08-01 23:57:16 +0000996 case 4: Kind = SectionKind::getMergeableConst4(); break;
997 case 8: Kind = SectionKind::getMergeableConst8(); break;
998 case 16: Kind = SectionKind::getMergeableConst16();break;
999 default: Kind = SectionKind::getMergeableConst(); break;
Chris Lattner4c509222009-07-26 07:00:12 +00001000 }
Chris Lattner5c2f7892009-07-26 06:26:55 +00001001 }
1002
Chris Lattner83d77fa2009-08-01 23:46:12 +00001003 const MCSection *S = getObjFileLowering().getSectionForConstant(Kind);
Jim Grosbach83d80832011-03-29 23:20:22 +00001004
Evan Cheng1606e8e2009-03-13 07:51:59 +00001005 // The number of sections are small, just do a linear search from the
1006 // last section to the first.
1007 bool Found = false;
1008 unsigned SecIdx = CPSections.size();
1009 while (SecIdx != 0) {
1010 if (CPSections[--SecIdx].S == S) {
1011 Found = true;
1012 break;
1013 }
1014 }
1015 if (!Found) {
1016 SecIdx = CPSections.size();
1017 CPSections.push_back(SectionCPs(S, Align));
1018 }
1019
1020 if (Align > CPSections[SecIdx].Alignment)
1021 CPSections[SecIdx].Alignment = Align;
1022 CPSections[SecIdx].CPEs.push_back(i);
Evan Cheng2d2cec12006-06-29 00:26:09 +00001023 }
1024
Anton Korobeynikov088ae832008-09-24 22:17:59 +00001025 // Now print stuff into the calculated sections.
Evan Cheng1606e8e2009-03-13 07:51:59 +00001026 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) {
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001027 OutStreamer.SwitchSection(CPSections[i].S);
Evan Cheng1606e8e2009-03-13 07:51:59 +00001028 EmitAlignment(Log2_32(CPSections[i].Alignment));
Evan Cheng2d2cec12006-06-29 00:26:09 +00001029
Evan Cheng1606e8e2009-03-13 07:51:59 +00001030 unsigned Offset = 0;
1031 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) {
1032 unsigned CPI = CPSections[i].CPEs[j];
1033 MachineConstantPoolEntry CPE = CP[CPI];
Anton Korobeynikov088ae832008-09-24 22:17:59 +00001034
Chris Lattner3029f922006-02-09 04:46:04 +00001035 // Emit inter-object padding for alignment.
Evan Cheng1606e8e2009-03-13 07:51:59 +00001036 unsigned AlignMask = CPE.getAlignment() - 1;
1037 unsigned NewOffset = (Offset + AlignMask) & ~AlignMask;
Chris Lattneraaec2052010-01-19 19:46:13 +00001038 OutStreamer.EmitFill(NewOffset - Offset, 0/*fillval*/, 0/*addrspace*/);
Evan Cheng1606e8e2009-03-13 07:51:59 +00001039
Chris Lattnerdb125cf2011-07-18 04:54:35 +00001040 Type *Ty = CPE.getType();
Micah Villmow3574eca2012-10-08 16:38:25 +00001041 Offset = NewOffset + TM.getDataLayout()->getTypeAllocSize(Ty);
Chris Lattner39248682010-01-23 05:19:23 +00001042 OutStreamer.EmitLabel(GetCPISymbol(CPI));
1043
Evan Cheng1606e8e2009-03-13 07:51:59 +00001044 if (CPE.isMachineConstantPoolEntry())
1045 EmitMachineConstantPoolValue(CPE.Val.MachineCPVal);
1046 else
1047 EmitGlobalConstant(CPE.Val.ConstVal);
Chris Lattner3029f922006-02-09 04:46:04 +00001048 }
Chris Lattner3b4fd322005-11-21 08:25:09 +00001049 }
1050}
1051
Nate Begeman37efe672006-04-22 18:53:45 +00001052/// EmitJumpTableInfo - Print assembly representations of the jump tables used
Jim Grosbach83d80832011-03-29 23:20:22 +00001053/// by the current function to the current output stream.
Nate Begeman37efe672006-04-22 18:53:45 +00001054///
Chris Lattner14c38ec2010-01-28 01:02:27 +00001055void AsmPrinter::EmitJumpTableInfo() {
1056 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
Chris Lattner44e87252010-01-25 22:41:33 +00001057 if (MJTI == 0) return;
Richard Osborne95da6052010-03-11 14:58:16 +00001058 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return;
Nate Begeman37efe672006-04-22 18:53:45 +00001059 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
1060 if (JT.empty()) return;
Anton Korobeynikov9de19342007-11-14 09:18:41 +00001061
Jim Grosbach83d80832011-03-29 23:20:22 +00001062 // Pick the directive to use to print the jump table entries, and switch to
Nate Begeman2f1ae882006-07-27 01:13:04 +00001063 // the appropriate section.
Chris Lattner14c38ec2010-01-28 01:02:27 +00001064 const Function *F = MF->getFunction();
Evan Chengb13bafe2009-06-18 20:37:15 +00001065 bool JTInDiffSection = false;
Chris Lattnerf1214cb2010-01-26 06:53:37 +00001066 if (// In PIC mode, we need to emit the jump table to the same section as the
1067 // function body itself, otherwise the label differences won't make sense.
1068 // FIXME: Need a better predicate for this: what about custom entries?
1069 MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 ||
1070 // We should also do if the section name is NULL or function is declared
1071 // in discardable section
1072 // FIXME: this isn't the right predicate, should be based on the MCSection
1073 // for the function.
1074 F->isWeakForLinker()) {
Chris Lattner14c38ec2010-01-28 01:02:27 +00001075 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F,Mang,TM));
Nate Begeman2f1ae882006-07-27 01:13:04 +00001076 } else {
Chris Lattner83d77fa2009-08-01 23:46:12 +00001077 // Otherwise, drop it in the readonly section.
Jim Grosbach83d80832011-03-29 23:20:22 +00001078 const MCSection *ReadOnlySection =
Chris Lattner27981192009-08-01 23:57:16 +00001079 getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly());
Chris Lattner6c2f9e12009-08-19 05:49:37 +00001080 OutStreamer.SwitchSection(ReadOnlySection);
Evan Chengb13bafe2009-06-18 20:37:15 +00001081 JTInDiffSection = true;
Nate Begeman2f1ae882006-07-27 01:13:04 +00001082 }
Chris Lattner071c62f2010-01-25 23:26:13 +00001083
Micah Villmow3574eca2012-10-08 16:38:25 +00001084 EmitAlignment(Log2_32(MJTI->getEntryAlignment(*TM.getDataLayout())));
Jim Grosbach83d80832011-03-29 23:20:22 +00001085
Jim Grosbache9525d82012-09-24 23:06:27 +00001086 // Jump tables in code sections are marked with a data_region directive
1087 // where that's supported.
1088 if (!JTInDiffSection)
1089 OutStreamer.EmitDataRegion(MCDR_DataRegionJT32);
1090
Chris Lattner3b131d72010-01-26 06:42:44 +00001091 for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) {
1092 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
Jim Grosbach83d80832011-03-29 23:20:22 +00001093
1094 // If this jump table was deleted, ignore it.
Chris Lattner07371882006-10-28 18:10:06 +00001095 if (JTBBs.empty()) continue;
Nate Begeman52a51e382006-08-12 21:29:52 +00001096
Chris Lattnere35df922010-01-26 05:15:20 +00001097 // For the EK_LabelDifference32 entry, if the target supports .set, emit a
1098 // .set directive for each unique entry. This reduces the number of
1099 // relocations the assembler will generate for the jump table.
1100 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 &&
Chris Lattnercee63322010-01-26 20:40:54 +00001101 MAI->hasSetDirective()) {
Chris Lattner3b131d72010-01-26 06:42:44 +00001102 SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets;
1103 const TargetLowering *TLI = TM.getTargetLowering();
Chris Lattner14c38ec2010-01-28 01:02:27 +00001104 const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF,JTI,OutContext);
Chris Lattner3b131d72010-01-26 06:42:44 +00001105 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) {
1106 const MachineBasicBlock *MBB = JTBBs[ii];
1107 if (!EmittedSets.insert(MBB)) continue;
Jim Grosbach83d80832011-03-29 23:20:22 +00001108
Chris Lattnerc618c8a2010-01-26 21:53:08 +00001109 // .set LJTSet, LBB32-base
1110 const MCExpr *LHS =
Chris Lattner1b2eb0e2010-03-13 21:04:28 +00001111 MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext);
Chris Lattnerc618c8a2010-01-26 21:53:08 +00001112 OutStreamer.EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()),
1113 MCBinaryExpr::CreateSub(LHS, Base, OutContext));
Chris Lattner3b131d72010-01-26 06:42:44 +00001114 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001115 }
1116
Duncan Sandsab4c3662011-02-15 09:23:02 +00001117 // On some targets (e.g. Darwin) we want to emit two consecutive labels
Chris Lattner393a8ee2007-01-18 01:12:56 +00001118 // before each jump table. The first label is never referenced, but tells
1119 // the assembler and linker the extents of the jump table object. The
1120 // second label is actually referenced by the code.
Chris Lattner39248682010-01-23 05:19:23 +00001121 if (JTInDiffSection && MAI->getLinkerPrivateGlobalPrefix()[0])
Chris Lattnerbeeb93e2010-01-26 05:58:28 +00001122 // FIXME: This doesn't have to have any specific name, just any randomly
1123 // named and numbered 'l' label would work. Simplify GetJTISymbol.
Chris Lattner3b131d72010-01-26 06:42:44 +00001124 OutStreamer.EmitLabel(GetJTISymbol(JTI, true));
Chris Lattner39248682010-01-23 05:19:23 +00001125
Chris Lattner3b131d72010-01-26 06:42:44 +00001126 OutStreamer.EmitLabel(GetJTISymbol(JTI));
Chris Lattner39248682010-01-23 05:19:23 +00001127
Chris Lattner6bf1def2010-01-26 05:10:10 +00001128 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii)
Chris Lattner3b131d72010-01-26 06:42:44 +00001129 EmitJumpTableEntry(MJTI, JTBBs[ii], JTI);
Nate Begeman37efe672006-04-22 18:53:45 +00001130 }
Jim Grosbache9525d82012-09-24 23:06:27 +00001131 if (!JTInDiffSection)
1132 OutStreamer.EmitDataRegion(MCDR_DataRegionEnd);
Nate Begeman37efe672006-04-22 18:53:45 +00001133}
1134
Chris Lattner6bf1def2010-01-26 05:10:10 +00001135/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the
1136/// current stream.
1137void AsmPrinter::EmitJumpTableEntry(const MachineJumpTableInfo *MJTI,
1138 const MachineBasicBlock *MBB,
1139 unsigned UID) const {
Jakob Stoklund Olesene5005d02011-02-09 21:52:06 +00001140 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");
Chris Lattnerff537ce2010-01-26 03:43:22 +00001141 const MCExpr *Value = 0;
1142 switch (MJTI->getEntryKind()) {
Richard Osborne95da6052010-03-11 14:58:16 +00001143 case MachineJumpTableInfo::EK_Inline:
David Blaikie4d6ccb52012-01-20 21:51:11 +00001144 llvm_unreachable("Cannot emit EK_Inline jump table entry");
Chris Lattner85fe0782010-01-26 04:05:28 +00001145 case MachineJumpTableInfo::EK_Custom32:
Chris Lattner6bf1def2010-01-26 05:10:10 +00001146 Value = TM.getTargetLowering()->LowerCustomJumpTableEntry(MJTI, MBB, UID,
Chris Lattner85fe0782010-01-26 04:05:28 +00001147 OutContext);
1148 break;
Chris Lattnerff537ce2010-01-26 03:43:22 +00001149 case MachineJumpTableInfo::EK_BlockAddress:
1150 // EK_BlockAddress - Each entry is a plain address of block, e.g.:
1151 // .word LBB123
Chris Lattner1b2eb0e2010-03-13 21:04:28 +00001152 Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext);
Chris Lattnerff537ce2010-01-26 03:43:22 +00001153 break;
Chris Lattnerff537ce2010-01-26 03:43:22 +00001154 case MachineJumpTableInfo::EK_GPRel32BlockAddress: {
1155 // EK_GPRel32BlockAddress - Each entry is an address of block, encoded
1156 // with a relocation as gp-relative, e.g.:
1157 // .gprel32 LBB123
Chris Lattner1b2eb0e2010-03-13 21:04:28 +00001158 MCSymbol *MBBSym = MBB->getSymbol();
Chris Lattner718fb592010-01-25 21:28:50 +00001159 OutStreamer.EmitGPRel32Value(MCSymbolRefExpr::Create(MBBSym, OutContext));
Chris Lattner78f485a2010-01-25 21:10:10 +00001160 return;
Anton Korobeynikov9de19342007-11-14 09:18:41 +00001161 }
Chris Lattner85fe0782010-01-26 04:05:28 +00001162
Akira Hatanaka6c2cf8b2012-02-03 04:33:00 +00001163 case MachineJumpTableInfo::EK_GPRel64BlockAddress: {
1164 // EK_GPRel64BlockAddress - Each entry is an address of block, encoded
1165 // with a relocation as gp-relative, e.g.:
1166 // .gpdword LBB123
1167 MCSymbol *MBBSym = MBB->getSymbol();
1168 OutStreamer.EmitGPRel64Value(MCSymbolRefExpr::Create(MBBSym, OutContext));
1169 return;
1170 }
1171
Chris Lattnerff537ce2010-01-26 03:43:22 +00001172 case MachineJumpTableInfo::EK_LabelDifference32: {
1173 // EK_LabelDifference32 - Each entry is the address of the block minus
1174 // the address of the jump table. This is used for PIC jump tables where
1175 // gprel32 is not supported. e.g.:
1176 // .word LBB123 - LJTI1_2
1177 // If the .set directive is supported, this is emitted as:
1178 // .set L4_5_set_123, LBB123 - LJTI1_2
1179 // .word L4_5_set_123
Jim Grosbach83d80832011-03-29 23:20:22 +00001180
1181 // If we have emitted set directives for the jump table entries, print
Chris Lattnerff537ce2010-01-26 03:43:22 +00001182 // them rather than the entries themselves. If we're emitting PIC, then
1183 // emit the table entries as differences between two text section labels.
Chris Lattnercee63322010-01-26 20:40:54 +00001184 if (MAI->hasSetDirective()) {
Chris Lattnerff537ce2010-01-26 03:43:22 +00001185 // If we used .set, reference the .set's symbol.
Chris Lattner6bf1def2010-01-26 05:10:10 +00001186 Value = MCSymbolRefExpr::Create(GetJTSetSymbol(UID, MBB->getNumber()),
Chris Lattnerff537ce2010-01-26 03:43:22 +00001187 OutContext);
1188 break;
1189 }
Chris Lattner1aca2492010-01-25 21:22:22 +00001190 // Otherwise, use the difference as the jump table entry.
Chris Lattner1b2eb0e2010-03-13 21:04:28 +00001191 Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext);
Chris Lattner6bf1def2010-01-26 05:10:10 +00001192 const MCExpr *JTI = MCSymbolRefExpr::Create(GetJTISymbol(UID), OutContext);
Chris Lattnerff537ce2010-01-26 03:43:22 +00001193 Value = MCBinaryExpr::CreateSub(Value, JTI, OutContext);
1194 break;
1195 }
Anton Korobeynikov9de19342007-11-14 09:18:41 +00001196 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001197
Chris Lattnerff537ce2010-01-26 03:43:22 +00001198 assert(Value && "Unknown entry kind!");
Jim Grosbach83d80832011-03-29 23:20:22 +00001199
Micah Villmow3574eca2012-10-08 16:38:25 +00001200 unsigned EntrySize = MJTI->getEntrySize(*TM.getDataLayout());
Chris Lattnerff537ce2010-01-26 03:43:22 +00001201 OutStreamer.EmitValue(Value, EntrySize, /*addrspace*/0);
Anton Korobeynikov9de19342007-11-14 09:18:41 +00001202}
1203
1204
Chris Lattnered138932005-12-13 06:32:10 +00001205/// EmitSpecialLLVMGlobal - Check to see if the specified global is a
1206/// special global used by LLVM. If so, emit it and return true, otherwise
1207/// do nothing and return false.
1208bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) {
Daniel Dunbar03d76512009-07-25 23:55:21 +00001209 if (GV->getName() == "llvm.used") {
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001210 if (MAI->hasNoDeadStrip()) // No need to emit this at all.
Andrew Lenharthb753a9b2007-08-22 19:33:11 +00001211 EmitLLVMUsedList(GV->getInitializer());
1212 return true;
1213 }
1214
Chris Lattner401e10c2009-07-20 06:14:25 +00001215 // Ignore debug and non-emitted data. This handles llvm.compiler.used.
Chris Lattner266c7bb2009-04-13 05:44:34 +00001216 if (GV->getSection() == "llvm.metadata" ||
1217 GV->hasAvailableExternallyLinkage())
1218 return true;
Jim Grosbach83d80832011-03-29 23:20:22 +00001219
Jim Laskey78098112006-03-07 22:00:35 +00001220 if (!GV->hasAppendingLinkage()) return false;
1221
1222 assert(GV->hasInitializer() && "Not a special LLVM global!");
Jim Grosbach83d80832011-03-29 23:20:22 +00001223
Chris Lattnerf231c072009-03-09 05:52:15 +00001224 if (GV->getName() == "llvm.global_ctors") {
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001225 EmitXXStructorList(GV->getInitializer(), /* isCtor */ true);
Jim Grosbach83d80832011-03-29 23:20:22 +00001226
Chris Lattner71eae712010-01-19 04:34:02 +00001227 if (TM.getRelocationModel() == Reloc::Static &&
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001228 MAI->hasStaticCtorDtorReferenceInStaticMode()) {
1229 StringRef Sym(".constructors_used");
1230 OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym),
Chris Lattnera5ad93a2010-01-23 06:39:22 +00001231 MCSA_Reference);
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001232 }
Chris Lattnerea3a9ff2009-03-09 08:18:48 +00001233 return true;
Jim Grosbach83d80832011-03-29 23:20:22 +00001234 }
1235
Chris Lattnerf231c072009-03-09 05:52:15 +00001236 if (GV->getName() == "llvm.global_dtors") {
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001237 EmitXXStructorList(GV->getInitializer(), /* isCtor */ false);
Chris Lattner71eae712010-01-19 04:34:02 +00001238
1239 if (TM.getRelocationModel() == Reloc::Static &&
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001240 MAI->hasStaticCtorDtorReferenceInStaticMode()) {
1241 StringRef Sym(".destructors_used");
1242 OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym),
Chris Lattnera5ad93a2010-01-23 06:39:22 +00001243 MCSA_Reference);
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001244 }
Chris Lattnerea3a9ff2009-03-09 08:18:48 +00001245 return true;
Chris Lattnered138932005-12-13 06:32:10 +00001246 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001247
Chris Lattnered138932005-12-13 06:32:10 +00001248 return false;
1249}
1250
Chris Lattner33adcfb2009-08-22 21:43:10 +00001251/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each
Dale Johannesend2e51af2008-09-09 22:29:13 +00001252/// global in the specified llvm.used list for which emitUsedDirectiveFor
1253/// is true, as being used with this directive.
Jay Foad7d715df2011-06-19 18:37:11 +00001254void AsmPrinter::EmitLLVMUsedList(const Constant *List) {
Dan Gohmana119de82009-06-14 23:30:43 +00001255 // Should be an array of 'i8*'.
Jay Foad7d715df2011-06-19 18:37:11 +00001256 const ConstantArray *InitList = dyn_cast<ConstantArray>(List);
Chris Lattnercb05af82006-09-26 03:38:18 +00001257 if (InitList == 0) return;
Jim Grosbach83d80832011-03-29 23:20:22 +00001258
Chris Lattnercb05af82006-09-26 03:38:18 +00001259 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
Chris Lattner16fe9902009-07-17 22:00:23 +00001260 const GlobalValue *GV =
1261 dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts());
Chris Lattner3a9be0e2010-01-23 05:51:36 +00001262 if (GV && getObjFileLowering().shouldEmitUsedDirectiveFor(GV, Mang))
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001263 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(GV), MCSA_NoDeadStrip);
Chris Lattnercb05af82006-09-26 03:38:18 +00001264 }
1265}
1266
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001267typedef std::pair<unsigned, Constant*> Structor;
Duncan Sandsfd9c4f72011-08-28 13:17:22 +00001268
Duncan Sands9a7d48a2011-09-29 16:01:46 +00001269static bool priority_order(const Structor& lhs, const Structor& rhs) {
Duncan Sandsfd9c4f72011-08-28 13:17:22 +00001270 return lhs.first < rhs.first;
1271}
1272
1273/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init
1274/// priority.
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001275void AsmPrinter::EmitXXStructorList(const Constant *List, bool isCtor) {
Chris Lattnered138932005-12-13 06:32:10 +00001276 // Should be an array of '{ int, void ()* }' structs. The first value is the
Duncan Sandsfd9c4f72011-08-28 13:17:22 +00001277 // init priority.
Chris Lattnered138932005-12-13 06:32:10 +00001278 if (!isa<ConstantArray>(List)) return;
Chris Lattner8de324b2005-12-21 01:17:37 +00001279
Duncan Sandsfd9c4f72011-08-28 13:17:22 +00001280 // Sanity check the structors list.
1281 const ConstantArray *InitList = dyn_cast<ConstantArray>(List);
1282 if (!InitList) return; // Not an array!
1283 StructType *ETy = dyn_cast<StructType>(InitList->getType()->getElementType());
1284 if (!ETy || ETy->getNumElements() != 2) return; // Not an array of pairs!
1285 if (!isa<IntegerType>(ETy->getTypeAtIndex(0U)) ||
1286 !isa<PointerType>(ETy->getTypeAtIndex(1U))) return; // Not (int, ptr).
1287
1288 // Gather the structors in a form that's convenient for sorting by priority.
1289 SmallVector<Structor, 8> Structors;
1290 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
1291 ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
1292 if (!CS) continue; // Malformed.
1293 if (CS->getOperand(1)->isNullValue())
1294 break; // Found a null terminator, skip the rest.
1295 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
1296 if (!Priority) continue; // Malformed.
1297 Structors.push_back(std::make_pair(Priority->getLimitedValue(65535),
1298 CS->getOperand(1)));
1299 }
1300
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001301 // Emit the function pointers in the target-specific order
Micah Villmow3574eca2012-10-08 16:38:25 +00001302 const DataLayout *TD = TM.getDataLayout();
Micah Villmow2c39b152012-10-15 16:24:29 +00001303 unsigned Align = Log2_32(TD->getPointerPrefAlignment(0));
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001304 std::stable_sort(Structors.begin(), Structors.end(), priority_order);
1305 for (unsigned i = 0, e = Structors.size(); i != e; ++i) {
1306 const MCSection *OutputSection =
1307 (isCtor ?
1308 getObjFileLowering().getStaticCtorSection(Structors[i].first) :
1309 getObjFileLowering().getStaticDtorSection(Structors[i].first));
1310 OutStreamer.SwitchSection(OutputSection);
1311 if (OutStreamer.getCurrentSection() != OutStreamer.getPreviousSection())
1312 EmitAlignment(Align);
James Molloy34982572012-01-26 09:25:43 +00001313 EmitXXStructor(Structors[i].second);
Anton Korobeynikov4a99f592012-01-25 22:24:19 +00001314 }
Chris Lattnered138932005-12-13 06:32:10 +00001315}
Chris Lattner3b4fd322005-11-21 08:25:09 +00001316
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001317//===--------------------------------------------------------------------===//
1318// Emission and print routines
1319//
1320
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001321/// EmitInt8 - Emit a byte directive and value.
1322///
1323void AsmPrinter::EmitInt8(int Value) const {
Chris Lattner5eaa54e2010-01-20 06:45:39 +00001324 OutStreamer.EmitIntValue(Value, 1, 0/*addrspace*/);
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001325}
1326
1327/// EmitInt16 - Emit a short directive and value.
1328///
1329void AsmPrinter::EmitInt16(int Value) const {
Chris Lattner5eaa54e2010-01-20 06:45:39 +00001330 OutStreamer.EmitIntValue(Value, 2, 0/*addrspace*/);
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001331}
1332
1333/// EmitInt32 - Emit a long directive and value.
1334///
1335void AsmPrinter::EmitInt32(int Value) const {
Chris Lattner5eaa54e2010-01-20 06:45:39 +00001336 OutStreamer.EmitIntValue(Value, 4, 0/*addrspace*/);
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001337}
1338
Chris Lattner0d50c762010-03-08 23:58:37 +00001339/// EmitLabelDifference - Emit something like ".long Hi-Lo" where the size
1340/// in bytes of the directive is specified by Size and Hi/Lo specify the
1341/// labels. This implicitly uses .set if it is available.
1342void AsmPrinter::EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo,
1343 unsigned Size) const {
1344 // Get the Hi-Lo expression.
Jim Grosbach83d80832011-03-29 23:20:22 +00001345 const MCExpr *Diff =
Chris Lattner0d50c762010-03-08 23:58:37 +00001346 MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(Hi, OutContext),
1347 MCSymbolRefExpr::Create(Lo, OutContext),
1348 OutContext);
Jim Grosbach83d80832011-03-29 23:20:22 +00001349
Chris Lattner0d50c762010-03-08 23:58:37 +00001350 if (!MAI->hasSetDirective()) {
1351 OutStreamer.EmitValue(Diff, Size, 0/*AddrSpace*/);
1352 return;
1353 }
1354
1355 // Otherwise, emit with .set (aka assignment).
Chris Lattnerc0215722010-04-04 19:25:43 +00001356 MCSymbol *SetLabel = GetTempSymbol("set", SetCounter++);
Chris Lattner0d50c762010-03-08 23:58:37 +00001357 OutStreamer.EmitAssignment(SetLabel, Diff);
Chris Lattner6cde3e62010-03-09 00:39:24 +00001358 OutStreamer.EmitSymbolValue(SetLabel, Size, 0/*AddrSpace*/);
Chris Lattner0d50c762010-03-08 23:58:37 +00001359}
1360
Jim Grosbach83d80832011-03-29 23:20:22 +00001361/// EmitLabelOffsetDifference - Emit something like ".long Hi+Offset-Lo"
Devang Patelf2548ca2010-04-16 23:33:45 +00001362/// where the size in bytes of the directive is specified by Size and Hi/Lo
1363/// specify the labels. This implicitly uses .set if it is available.
1364void AsmPrinter::EmitLabelOffsetDifference(const MCSymbol *Hi, uint64_t Offset,
Jim Grosbach83d80832011-03-29 23:20:22 +00001365 const MCSymbol *Lo, unsigned Size)
Devang Patelf2548ca2010-04-16 23:33:45 +00001366 const {
Jim Grosbach83d80832011-03-29 23:20:22 +00001367
Devang Patelf2548ca2010-04-16 23:33:45 +00001368 // Emit Hi+Offset - Lo
1369 // Get the Hi+Offset expression.
1370 const MCExpr *Plus =
Jim Grosbach83d80832011-03-29 23:20:22 +00001371 MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Hi, OutContext),
Devang Patelf2548ca2010-04-16 23:33:45 +00001372 MCConstantExpr::Create(Offset, OutContext),
1373 OutContext);
Jim Grosbach83d80832011-03-29 23:20:22 +00001374
Devang Patelf2548ca2010-04-16 23:33:45 +00001375 // Get the Hi+Offset-Lo expression.
Jim Grosbach83d80832011-03-29 23:20:22 +00001376 const MCExpr *Diff =
Devang Patelf2548ca2010-04-16 23:33:45 +00001377 MCBinaryExpr::CreateSub(Plus,
1378 MCSymbolRefExpr::Create(Lo, OutContext),
1379 OutContext);
Jim Grosbach83d80832011-03-29 23:20:22 +00001380
1381 if (!MAI->hasSetDirective())
Devang Patelf2548ca2010-04-16 23:33:45 +00001382 OutStreamer.EmitValue(Diff, 4, 0/*AddrSpace*/);
1383 else {
1384 // Otherwise, emit with .set (aka assignment).
1385 MCSymbol *SetLabel = GetTempSymbol("set", SetCounter++);
1386 OutStreamer.EmitAssignment(SetLabel, Diff);
1387 OutStreamer.EmitSymbolValue(SetLabel, 4, 0/*AddrSpace*/);
1388 }
1389}
Devang Patelb1fcfbe2010-09-02 16:43:44 +00001390
Jim Grosbach83d80832011-03-29 23:20:22 +00001391/// EmitLabelPlusOffset - Emit something like ".long Label+Offset"
Devang Patelb1fcfbe2010-09-02 16:43:44 +00001392/// where the size in bytes of the directive is specified by Size and Label
1393/// specifies the label. This implicitly uses .set if it is available.
1394void AsmPrinter::EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
Jim Grosbach83d80832011-03-29 23:20:22 +00001395 unsigned Size)
Devang Patelb1fcfbe2010-09-02 16:43:44 +00001396 const {
Jim Grosbach83d80832011-03-29 23:20:22 +00001397
Nick Lewyckyffccd922012-06-22 01:25:12 +00001398 // Emit Label+Offset (or just Label if Offset is zero)
1399 const MCExpr *Expr = MCSymbolRefExpr::Create(Label, OutContext);
1400 if (Offset)
1401 Expr = MCBinaryExpr::CreateAdd(Expr,
1402 MCConstantExpr::Create(Offset, OutContext),
1403 OutContext);
Jim Grosbach83d80832011-03-29 23:20:22 +00001404
Nick Lewyckyffccd922012-06-22 01:25:12 +00001405 OutStreamer.EmitValue(Expr, Size, 0/*AddrSpace*/);
Devang Patelb1fcfbe2010-09-02 16:43:44 +00001406}
Jim Grosbach83d80832011-03-29 23:20:22 +00001407
Chris Lattner0d50c762010-03-08 23:58:37 +00001408
Jim Laskeyf1cdea12007-01-25 15:12:02 +00001409//===----------------------------------------------------------------------===//
1410
Chris Lattner3a420532007-05-31 18:57:45 +00001411// EmitAlignment - Emit an alignment directive to the specified power of
1412// two boundary. For example, if you pass in 3 here, you will get an 8
1413// byte alignment. If a global value is specified, and if that global has
Chris Lattnere87f7bb2010-04-28 19:58:07 +00001414// an explicit alignment requested, it will override the alignment request
1415// if required for correctness.
Chris Lattner3a420532007-05-31 18:57:45 +00001416//
Chris Lattnera7b611c2010-04-28 01:08:40 +00001417void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const {
Micah Villmow3574eca2012-10-08 16:38:25 +00001418 if (GV) NumBits = getGVAlignmentLog2(GV, *TM.getDataLayout(), NumBits);
Jim Grosbach83d80832011-03-29 23:20:22 +00001419
Chris Lattnere87f7bb2010-04-28 19:58:07 +00001420 if (NumBits == 0) return; // 1-byte aligned: no need to emit alignment.
Jim Grosbach83d80832011-03-29 23:20:22 +00001421
Chris Lattnerdabf07c2009-08-18 06:15:16 +00001422 if (getCurrentSection()->getKind().isText())
Chris Lattner2cce3712010-02-23 18:46:22 +00001423 OutStreamer.EmitCodeAlignment(1 << NumBits);
1424 else
1425 OutStreamer.EmitValueToAlignment(1 << NumBits, 0, 1, 0);
Chris Lattnerbfddc202004-08-17 19:14:29 +00001426}
David Greenea5bb59f2009-08-05 21:00:52 +00001427
Chris Lattner44e05082010-04-20 06:20:21 +00001428//===----------------------------------------------------------------------===//
1429// Constant emission.
1430//===----------------------------------------------------------------------===//
1431
Chad Rosierc53ade22012-09-07 18:16:38 +00001432/// lowerConstant - Lower the specified LLVM Constant to an MCExpr.
Chris Lattner52492ac2010-01-23 06:17:14 +00001433///
Chad Rosierc53ade22012-09-07 18:16:38 +00001434static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) {
Chris Lattner52492ac2010-01-23 06:17:14 +00001435 MCContext &Ctx = AP.OutContext;
Jim Grosbach83d80832011-03-29 23:20:22 +00001436
Chris Lattner52492ac2010-01-23 06:17:14 +00001437 if (CV->isNullValue() || isa<UndefValue>(CV))
1438 return MCConstantExpr::Create(0, Ctx);
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001439
Chris Lattner52492ac2010-01-23 06:17:14 +00001440 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
1441 return MCConstantExpr::Create(CI->getZExtValue(), Ctx);
Jim Grosbach83d80832011-03-29 23:20:22 +00001442
Chris Lattner52492ac2010-01-23 06:17:14 +00001443 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
Chris Lattnerdeb0cba2010-03-12 21:09:07 +00001444 return MCSymbolRefExpr::Create(AP.Mang->getSymbol(GV), Ctx);
Bill Wendling3d7ff082010-08-18 18:41:13 +00001445
Chris Lattner52492ac2010-01-23 06:17:14 +00001446 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
1447 return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx);
Jim Grosbach83d80832011-03-29 23:20:22 +00001448
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001449 const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
1450 if (CE == 0) {
Chris Lattner52492ac2010-01-23 06:17:14 +00001451 llvm_unreachable("Unknown constant value to lower!");
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001452 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001453
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001454 switch (CE->getOpcode()) {
Dan Gohman618f1772010-02-08 22:02:38 +00001455 default:
1456 // If the code isn't optimized, there may be outstanding folding
Micah Villmow3574eca2012-10-08 16:38:25 +00001457 // opportunities. Attempt to fold the expression using DataLayout as a
Dan Gohman618f1772010-02-08 22:02:38 +00001458 // last resort before giving up.
Dan Gohman54e72ec2010-02-08 22:19:11 +00001459 if (Constant *C =
Micah Villmow3574eca2012-10-08 16:38:25 +00001460 ConstantFoldConstantExpression(CE, AP.TM.getDataLayout()))
Dan Gohman54e72ec2010-02-08 22:19:11 +00001461 if (C != CE)
Chad Rosierc53ade22012-09-07 18:16:38 +00001462 return lowerConstant(C, AP);
Dan Gohman9f6a68622010-08-04 18:51:09 +00001463
1464 // Otherwise report the problem to the user.
1465 {
1466 std::string S;
1467 raw_string_ostream OS(S);
1468 OS << "Unsupported expression in static initializer: ";
1469 WriteAsOperand(OS, CE, /*PrintType=*/false,
1470 !AP.MF ? 0 : AP.MF->getFunction()->getParent());
1471 report_fatal_error(OS.str());
1472 }
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001473 case Instruction::GetElementPtr: {
Micah Villmow3574eca2012-10-08 16:38:25 +00001474 const DataLayout &TD = *AP.TM.getDataLayout();
Chris Lattner52492ac2010-01-23 06:17:14 +00001475 // Generate a symbolic expression for the byte address
1476 const Constant *PtrVal = CE->getOperand(0);
1477 SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end());
Jay Foad8fbbb392011-07-19 14:01:37 +00001478 int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), IdxVec);
Jim Grosbach83d80832011-03-29 23:20:22 +00001479
Chad Rosierc53ade22012-09-07 18:16:38 +00001480 const MCExpr *Base = lowerConstant(CE->getOperand(0), AP);
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001481 if (Offset == 0)
Chris Lattner52492ac2010-01-23 06:17:14 +00001482 return Base;
Jim Grosbach83d80832011-03-29 23:20:22 +00001483
Micah Villmow2c39b152012-10-15 16:24:29 +00001484 unsigned AS = cast<PointerType>(CE->getType())->getAddressSpace();
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001485 // Truncate/sext the offset to the pointer size.
Micah Villmow2c39b152012-10-15 16:24:29 +00001486 unsigned Width = TD.getPointerSizeInBits(AS);
Richard Smith1144af32012-08-24 23:29:28 +00001487 if (Width < 64)
1488 Offset = SignExtend64(Offset, Width);
Jim Grosbach83d80832011-03-29 23:20:22 +00001489
Chris Lattner52492ac2010-01-23 06:17:14 +00001490 return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx),
1491 Ctx);
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001492 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001493
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001494 case Instruction::Trunc:
1495 // We emit the value and depend on the assembler to truncate the generated
1496 // expression properly. This is important for differences between
1497 // blockaddress labels. Since the two labels are in the same function, it
1498 // is reasonable to treat their delta as a 32-bit value.
Chris Lattner52492ac2010-01-23 06:17:14 +00001499 // FALL THROUGH.
1500 case Instruction::BitCast:
Chad Rosierc53ade22012-09-07 18:16:38 +00001501 return lowerConstant(CE->getOperand(0), AP);
Chris Lattner52492ac2010-01-23 06:17:14 +00001502
1503 case Instruction::IntToPtr: {
Micah Villmow3574eca2012-10-08 16:38:25 +00001504 const DataLayout &TD = *AP.TM.getDataLayout();
Chris Lattner52492ac2010-01-23 06:17:14 +00001505 // Handle casts to pointers by changing them into casts to the appropriate
1506 // integer type. This promotes constant folding and simplifies this code.
1507 Constant *Op = CE->getOperand(0);
1508 Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()),
1509 false/*ZExt*/);
Chad Rosierc53ade22012-09-07 18:16:38 +00001510 return lowerConstant(Op, AP);
Chris Lattner52492ac2010-01-23 06:17:14 +00001511 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001512
Chris Lattner52492ac2010-01-23 06:17:14 +00001513 case Instruction::PtrToInt: {
Micah Villmow3574eca2012-10-08 16:38:25 +00001514 const DataLayout &TD = *AP.TM.getDataLayout();
Chris Lattner52492ac2010-01-23 06:17:14 +00001515 // Support only foldable casts to/from pointers that can be eliminated by
1516 // changing the pointer to the appropriately sized integer type.
1517 Constant *Op = CE->getOperand(0);
Chris Lattnerdb125cf2011-07-18 04:54:35 +00001518 Type *Ty = CE->getType();
Chris Lattner52492ac2010-01-23 06:17:14 +00001519
Chad Rosierc53ade22012-09-07 18:16:38 +00001520 const MCExpr *OpExpr = lowerConstant(Op, AP);
Chris Lattner52492ac2010-01-23 06:17:14 +00001521
1522 // We can emit the pointer value into this slot if the slot is an
1523 // integer slot equal to the size of the pointer.
1524 if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType()))
1525 return OpExpr;
1526
1527 // Otherwise the pointer is smaller than the resultant integer, mask off
1528 // the high bits so we are sure to get a proper truncation if the input is
1529 // a constant expr.
1530 unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType());
1531 const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx);
1532 return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx);
1533 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001534
Dan Gohman5938a3e2010-02-09 00:02:37 +00001535 // The MC library also has a right-shift operator, but it isn't consistently
1536 // signed or unsigned between different targets.
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001537 case Instruction::Add:
1538 case Instruction::Sub:
Dan Gohman5938a3e2010-02-09 00:02:37 +00001539 case Instruction::Mul:
1540 case Instruction::SDiv:
1541 case Instruction::SRem:
1542 case Instruction::Shl:
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001543 case Instruction::And:
1544 case Instruction::Or:
Chris Lattner52492ac2010-01-23 06:17:14 +00001545 case Instruction::Xor: {
Chad Rosierc53ade22012-09-07 18:16:38 +00001546 const MCExpr *LHS = lowerConstant(CE->getOperand(0), AP);
1547 const MCExpr *RHS = lowerConstant(CE->getOperand(1), AP);
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001548 switch (CE->getOpcode()) {
Chris Lattner52492ac2010-01-23 06:17:14 +00001549 default: llvm_unreachable("Unknown binary operator constant cast expr");
1550 case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx);
1551 case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx);
Dan Gohman5938a3e2010-02-09 00:02:37 +00001552 case Instruction::Mul: return MCBinaryExpr::CreateMul(LHS, RHS, Ctx);
1553 case Instruction::SDiv: return MCBinaryExpr::CreateDiv(LHS, RHS, Ctx);
1554 case Instruction::SRem: return MCBinaryExpr::CreateMod(LHS, RHS, Ctx);
1555 case Instruction::Shl: return MCBinaryExpr::CreateShl(LHS, RHS, Ctx);
Chris Lattner52492ac2010-01-23 06:17:14 +00001556 case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx);
1557 case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx);
1558 case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx);
Chris Lattnerfe0e7ed2010-01-13 04:29:19 +00001559 }
Chris Lattner52492ac2010-01-23 06:17:14 +00001560 }
Chris Lattnera80ba712004-08-16 23:15:22 +00001561 }
1562}
Chris Lattner1b7e2352004-08-17 06:36:49 +00001563
Chad Rosierc53ade22012-09-07 18:16:38 +00001564static void emitGlobalConstantImpl(const Constant *C, unsigned AddrSpace,
Chris Lattner44e05082010-04-20 06:20:21 +00001565 AsmPrinter &AP);
1566
David Greened92e2e42011-08-31 17:30:56 +00001567/// isRepeatedByteSequence - Determine whether the given value is
1568/// composed of a repeated sequence of identical bytes and return the
1569/// byte value. If it is not a repeated sequence, return -1.
Chris Lattner9e631da2012-01-24 09:31:43 +00001570static int isRepeatedByteSequence(const ConstantDataSequential *V) {
1571 StringRef Data = V->getRawDataValues();
1572 assert(!Data.empty() && "Empty aggregates should be CAZ node");
1573 char C = Data[0];
1574 for (unsigned i = 1, e = Data.size(); i != e; ++i)
1575 if (Data[i] != C) return -1;
Chandler Carruthbeb05952012-01-30 23:47:44 +00001576 return static_cast<uint8_t>(C); // Ensure 255 is not returned as -1.
Chris Lattner9e631da2012-01-24 09:31:43 +00001577}
1578
1579
1580/// isRepeatedByteSequence - Determine whether the given value is
1581/// composed of a repeated sequence of identical bytes and return the
1582/// byte value. If it is not a repeated sequence, return -1.
David Greened92e2e42011-08-31 17:30:56 +00001583static int isRepeatedByteSequence(const Value *V, TargetMachine &TM) {
1584
1585 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
1586 if (CI->getBitWidth() > 64) return -1;
1587
Micah Villmow3574eca2012-10-08 16:38:25 +00001588 uint64_t Size = TM.getDataLayout()->getTypeAllocSize(V->getType());
David Greened92e2e42011-08-31 17:30:56 +00001589 uint64_t Value = CI->getZExtValue();
1590
1591 // Make sure the constant is at least 8 bits long and has a power
1592 // of 2 bit width. This guarantees the constant bit width is
1593 // always a multiple of 8 bits, avoiding issues with padding out
1594 // to Size and other such corner cases.
1595 if (CI->getBitWidth() < 8 || !isPowerOf2_64(CI->getBitWidth())) return -1;
1596
1597 uint8_t Byte = static_cast<uint8_t>(Value);
1598
1599 for (unsigned i = 1; i < Size; ++i) {
1600 Value >>= 8;
1601 if (static_cast<uint8_t>(Value) != Byte) return -1;
1602 }
1603 return Byte;
1604 }
1605 if (const ConstantArray *CA = dyn_cast<ConstantArray>(V)) {
1606 // Make sure all array elements are sequences of the same repeated
1607 // byte.
Chris Lattner9e631da2012-01-24 09:31:43 +00001608 assert(CA->getNumOperands() != 0 && "Should be a CAZ");
David Greened92e2e42011-08-31 17:30:56 +00001609 int Byte = isRepeatedByteSequence(CA->getOperand(0), TM);
1610 if (Byte == -1) return -1;
1611
1612 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
1613 int ThisByte = isRepeatedByteSequence(CA->getOperand(i), TM);
1614 if (ThisByte == -1) return -1;
1615 if (Byte != ThisByte) return -1;
1616 }
1617 return Byte;
1618 }
Chris Lattner9e631da2012-01-24 09:31:43 +00001619
1620 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V))
1621 return isRepeatedByteSequence(CDS);
David Greened92e2e42011-08-31 17:30:56 +00001622
1623 return -1;
1624}
1625
Chad Rosierc53ade22012-09-07 18:16:38 +00001626static void emitGlobalConstantDataSequential(const ConstantDataSequential *CDS,
Chris Lattner9e631da2012-01-24 09:31:43 +00001627 unsigned AddrSpace,AsmPrinter &AP){
1628
1629 // See if we can aggregate this into a .fill, if so, emit it as such.
1630 int Value = isRepeatedByteSequence(CDS, AP.TM);
1631 if (Value != -1) {
Micah Villmow3574eca2012-10-08 16:38:25 +00001632 uint64_t Bytes = AP.TM.getDataLayout()->getTypeAllocSize(CDS->getType());
Chris Lattnerc63352f2012-01-31 03:39:24 +00001633 // Don't emit a 1-byte object as a .fill.
1634 if (Bytes > 1)
1635 return AP.OutStreamer.EmitFill(Bytes, Value, AddrSpace);
Chris Lattner9e631da2012-01-24 09:31:43 +00001636 }
1637
1638 // If this can be emitted with .ascii/.asciz, emit it as such.
1639 if (CDS->isString())
1640 return AP.OutStreamer.EmitBytes(CDS->getAsString(), AddrSpace);
1641
1642 // Otherwise, emit the values in successive locations.
1643 unsigned ElementByteSize = CDS->getElementByteSize();
1644 if (isa<IntegerType>(CDS->getElementType())) {
Chris Lattner0f193b82012-01-25 01:27:20 +00001645 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
Chris Lattnerb66fb5a2012-01-30 05:55:11 +00001646 if (AP.isVerbose())
1647 AP.OutStreamer.GetCommentOS() << format("0x%" PRIx64 "\n",
1648 CDS->getElementAsInteger(i));
Chris Lattner9e631da2012-01-24 09:31:43 +00001649 AP.OutStreamer.EmitIntValue(CDS->getElementAsInteger(i),
1650 ElementByteSize, AddrSpace);
1651 }
Chris Lattner6e64c382012-01-30 05:49:43 +00001652 } else if (ElementByteSize == 4) {
1653 // FP Constants are printed as integer constants to avoid losing
1654 // precision.
1655 assert(CDS->getElementType()->isFloatTy());
Chris Lattner0f193b82012-01-25 01:27:20 +00001656 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
Chris Lattner9e631da2012-01-24 09:31:43 +00001657 union {
1658 float F;
1659 uint32_t I;
1660 };
1661
1662 F = CDS->getElementAsFloat(i);
1663 if (AP.isVerbose())
1664 AP.OutStreamer.GetCommentOS() << "float " << F << '\n';
1665 AP.OutStreamer.EmitIntValue(I, 4, AddrSpace);
1666 }
Chris Lattner6e64c382012-01-30 05:49:43 +00001667 } else {
1668 assert(CDS->getElementType()->isDoubleTy());
1669 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
1670 union {
1671 double F;
1672 uint64_t I;
1673 };
1674
1675 F = CDS->getElementAsDouble(i);
1676 if (AP.isVerbose())
1677 AP.OutStreamer.GetCommentOS() << "double " << F << '\n';
1678 AP.OutStreamer.EmitIntValue(I, 8, AddrSpace);
1679 }
Chris Lattner9e631da2012-01-24 09:31:43 +00001680 }
1681
Micah Villmow3574eca2012-10-08 16:38:25 +00001682 const DataLayout &TD = *AP.TM.getDataLayout();
Chris Lattner6e64c382012-01-30 05:49:43 +00001683 unsigned Size = TD.getTypeAllocSize(CDS->getType());
1684 unsigned EmittedSize = TD.getTypeAllocSize(CDS->getType()->getElementType()) *
1685 CDS->getNumElements();
1686 if (unsigned Padding = Size - EmittedSize)
1687 AP.OutStreamer.EmitZeros(Padding, AddrSpace);
1688
Chris Lattner9e631da2012-01-24 09:31:43 +00001689}
1690
Chad Rosierc53ade22012-09-07 18:16:38 +00001691static void emitGlobalConstantArray(const ConstantArray *CA, unsigned AddrSpace,
Chris Lattner91093ec2010-01-19 19:10:44 +00001692 AsmPrinter &AP) {
Chris Lattner18c7f802012-02-05 02:29:43 +00001693 // See if we can aggregate some values. Make sure it can be
1694 // represented as a series of bytes of the constant value.
1695 int Value = isRepeatedByteSequence(CA, AP.TM);
David Greened92e2e42011-08-31 17:30:56 +00001696
Chris Lattner18c7f802012-02-05 02:29:43 +00001697 if (Value != -1) {
Micah Villmow3574eca2012-10-08 16:38:25 +00001698 uint64_t Bytes = AP.TM.getDataLayout()->getTypeAllocSize(CA->getType());
Chris Lattner18c7f802012-02-05 02:29:43 +00001699 AP.OutStreamer.EmitFill(Bytes, Value, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001700 }
Chris Lattner18c7f802012-02-05 02:29:43 +00001701 else {
1702 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
Chad Rosierc53ade22012-09-07 18:16:38 +00001703 emitGlobalConstantImpl(CA->getOperand(i), AddrSpace, AP);
Chris Lattner18c7f802012-02-05 02:29:43 +00001704 }
Dan Gohman00d448a2008-12-22 21:14:27 +00001705}
1706
Chad Rosierc53ade22012-09-07 18:16:38 +00001707static void emitGlobalConstantVector(const ConstantVector *CV,
Chris Lattner91093ec2010-01-19 19:10:44 +00001708 unsigned AddrSpace, AsmPrinter &AP) {
Chris Lattnerbcb83e52010-01-20 07:41:15 +00001709 for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
Chad Rosierc53ade22012-09-07 18:16:38 +00001710 emitGlobalConstantImpl(CV->getOperand(i), AddrSpace, AP);
Nick Lewycky5b7ac142011-06-22 18:55:03 +00001711
Micah Villmow3574eca2012-10-08 16:38:25 +00001712 const DataLayout &TD = *AP.TM.getDataLayout();
Nick Lewycky5b7ac142011-06-22 18:55:03 +00001713 unsigned Size = TD.getTypeAllocSize(CV->getType());
1714 unsigned EmittedSize = TD.getTypeAllocSize(CV->getType()->getElementType()) *
1715 CV->getType()->getNumElements();
1716 if (unsigned Padding = Size - EmittedSize)
1717 AP.OutStreamer.EmitZeros(Padding, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001718}
1719
Chad Rosierc53ade22012-09-07 18:16:38 +00001720static void emitGlobalConstantStruct(const ConstantStruct *CS,
Chris Lattner91093ec2010-01-19 19:10:44 +00001721 unsigned AddrSpace, AsmPrinter &AP) {
Dan Gohman00d448a2008-12-22 21:14:27 +00001722 // Print the fields in successive locations. Pad to align if needed!
Micah Villmow3574eca2012-10-08 16:38:25 +00001723 const DataLayout *TD = AP.TM.getDataLayout();
Chris Lattner91093ec2010-01-19 19:10:44 +00001724 unsigned Size = TD->getTypeAllocSize(CS->getType());
Chris Lattner2dd245c2010-01-20 07:11:32 +00001725 const StructLayout *Layout = TD->getStructLayout(CS->getType());
Chris Lattner91093ec2010-01-19 19:10:44 +00001726 uint64_t SizeSoFar = 0;
1727 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) {
Chris Lattnerbcb83e52010-01-20 07:41:15 +00001728 const Constant *Field = CS->getOperand(i);
Dan Gohman00d448a2008-12-22 21:14:27 +00001729
1730 // Check if padding is needed and insert one or more 0s.
Chris Lattnerbcb83e52010-01-20 07:41:15 +00001731 uint64_t FieldSize = TD->getTypeAllocSize(Field->getType());
Chris Lattner2dd245c2010-01-20 07:11:32 +00001732 uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1))
1733 - Layout->getElementOffset(i)) - FieldSize;
1734 SizeSoFar += FieldSize + PadSize;
Dan Gohman00d448a2008-12-22 21:14:27 +00001735
1736 // Now print the actual field value.
Chad Rosierc53ade22012-09-07 18:16:38 +00001737 emitGlobalConstantImpl(Field, AddrSpace, AP);
Dan Gohman00d448a2008-12-22 21:14:27 +00001738
1739 // Insert padding - this may include padding to increase the size of the
1740 // current field up to the ABI size (if the struct is not packed) as well
1741 // as padding to ensure that the next field starts at the right offset.
Chris Lattner2dd245c2010-01-20 07:11:32 +00001742 AP.OutStreamer.EmitZeros(PadSize, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001743 }
Chris Lattner2dd245c2010-01-20 07:11:32 +00001744 assert(SizeSoFar == Layout->getSizeInBytes() &&
Dan Gohman00d448a2008-12-22 21:14:27 +00001745 "Layout of constant struct may be incorrect!");
1746}
1747
Chad Rosierc53ade22012-09-07 18:16:38 +00001748static void emitGlobalConstantFP(const ConstantFP *CFP, unsigned AddrSpace,
Chris Lattner2dd245c2010-01-20 07:11:32 +00001749 AsmPrinter &AP) {
Dan Gohmane3376ec2011-12-20 00:02:33 +00001750 if (CFP->getType()->isHalfTy()) {
Chris Lattner3f53c832010-04-04 18:52:31 +00001751 if (AP.isVerbose()) {
Dan Gohmane3376ec2011-12-20 00:02:33 +00001752 SmallString<10> Str;
1753 CFP->getValueAPF().toString(Str);
1754 AP.OutStreamer.GetCommentOS() << "half " << Str << '\n';
Chris Lattner09ce6742010-01-19 22:16:33 +00001755 }
Chris Lattner2dd245c2010-01-20 07:11:32 +00001756 uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
Dan Gohmane3376ec2011-12-20 00:02:33 +00001757 AP.OutStreamer.EmitIntValue(Val, 2, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001758 return;
Chris Lattnercf0fe8d2009-10-05 05:54:46 +00001759 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001760
Chris Lattnercf0fe8d2009-10-05 05:54:46 +00001761 if (CFP->getType()->isFloatTy()) {
Chris Lattner3f53c832010-04-04 18:52:31 +00001762 if (AP.isVerbose()) {
Chris Lattner0fd90fd2010-01-22 19:52:01 +00001763 float Val = CFP->getValueAPF().convertToFloat();
Jim Grosbach7c0bc002012-03-23 23:06:47 +00001764 uint64_t IntVal = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
1765 AP.OutStreamer.GetCommentOS() << "float " << Val << '\n'
1766 << " (" << format("0x%x", IntVal) << ")\n";
Dan Gohmana12e9d72009-08-12 18:32:22 +00001767 }
Chris Lattner2dd245c2010-01-20 07:11:32 +00001768 uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
1769 AP.OutStreamer.EmitIntValue(Val, 4, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001770 return;
Chris Lattnercf0fe8d2009-10-05 05:54:46 +00001771 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001772
Dan Gohmane3376ec2011-12-20 00:02:33 +00001773 // FP Constants are printed as integer constants to avoid losing
1774 // precision.
1775 if (CFP->getType()->isDoubleTy()) {
1776 if (AP.isVerbose()) {
1777 double Val = CFP->getValueAPF().convertToDouble();
Jim Grosbach7c0bc002012-03-23 23:06:47 +00001778 uint64_t IntVal = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
1779 AP.OutStreamer.GetCommentOS() << "double " << Val << '\n'
1780 << " (" << format("0x%lx", IntVal) << ")\n";
Dan Gohmane3376ec2011-12-20 00:02:33 +00001781 }
1782
1783 uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue();
1784 AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace);
1785 return;
1786 }
1787
Chris Lattnercf0fe8d2009-10-05 05:54:46 +00001788 if (CFP->getType()->isX86_FP80Ty()) {
Dan Gohman00d448a2008-12-22 21:14:27 +00001789 // all long double variants are printed as hex
Dale Johannesen343b42e2010-04-07 01:15:14 +00001790 // API needed to prevent premature destruction
Chris Lattner09ce6742010-01-19 22:16:33 +00001791 APInt API = CFP->getValueAPF().bitcastToAPInt();
1792 const uint64_t *p = API.getRawData();
Chris Lattner3f53c832010-04-04 18:52:31 +00001793 if (AP.isVerbose()) {
Chris Lattner72b5ebc2010-01-19 22:11:05 +00001794 // Convert to double so we can print the approximate val as a comment.
1795 APFloat DoubleVal = CFP->getValueAPF();
1796 bool ignored;
1797 DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
1798 &ignored);
Chris Lattner0fd90fd2010-01-22 19:52:01 +00001799 AP.OutStreamer.GetCommentOS() << "x86_fp80 ~= "
1800 << DoubleVal.convertToDouble() << '\n';
Chris Lattner72b5ebc2010-01-19 22:11:05 +00001801 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001802
Micah Villmow3574eca2012-10-08 16:38:25 +00001803 if (AP.TM.getDataLayout()->isBigEndian()) {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001804 AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace);
1805 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace);
Chris Lattner72b5ebc2010-01-19 22:11:05 +00001806 } else {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001807 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace);
1808 AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001809 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001810
Chris Lattner9ceff942010-01-20 06:53:37 +00001811 // Emit the tail padding for the long double.
Micah Villmow3574eca2012-10-08 16:38:25 +00001812 const DataLayout &TD = *AP.TM.getDataLayout();
Chris Lattner2dd245c2010-01-20 07:11:32 +00001813 AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) -
1814 TD.getTypeStoreSize(CFP->getType()), AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001815 return;
Chris Lattnercf0fe8d2009-10-05 05:54:46 +00001816 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001817
Chris Lattner09ce6742010-01-19 22:16:33 +00001818 assert(CFP->getType()->isPPC_FP128Ty() &&
1819 "Floating point constant type not handled");
Dale Johannesen343b42e2010-04-07 01:15:14 +00001820 // All long double variants are printed as hex
1821 // API needed to prevent premature destruction.
Chris Lattner09ce6742010-01-19 22:16:33 +00001822 APInt API = CFP->getValueAPF().bitcastToAPInt();
1823 const uint64_t *p = API.getRawData();
Micah Villmow3574eca2012-10-08 16:38:25 +00001824 if (AP.TM.getDataLayout()->isBigEndian()) {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001825 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace);
1826 AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace);
Chris Lattner9ceff942010-01-20 06:53:37 +00001827 } else {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001828 AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace);
1829 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace);
Chris Lattner09ce6742010-01-19 22:16:33 +00001830 }
Dan Gohman00d448a2008-12-22 21:14:27 +00001831}
1832
Chad Rosierc53ade22012-09-07 18:16:38 +00001833static void emitGlobalConstantLargeInt(const ConstantInt *CI,
Chris Lattner2dd245c2010-01-20 07:11:32 +00001834 unsigned AddrSpace, AsmPrinter &AP) {
Micah Villmow3574eca2012-10-08 16:38:25 +00001835 const DataLayout *TD = AP.TM.getDataLayout();
Dan Gohman00d448a2008-12-22 21:14:27 +00001836 unsigned BitWidth = CI->getBitWidth();
Chris Lattner38c2b0a2010-01-13 04:39:46 +00001837 assert((BitWidth & 63) == 0 && "only support multiples of 64-bits");
Dan Gohman00d448a2008-12-22 21:14:27 +00001838
1839 // We don't expect assemblers to support integer data directives
1840 // for more than 64 bits, so we emit the data in at most 64-bit
1841 // quantities at a time.
1842 const uint64_t *RawData = CI->getValue().getRawData();
1843 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001844 uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i];
1845 AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace);
Dan Gohman00d448a2008-12-22 21:14:27 +00001846 }
1847}
1848
Chad Rosierc53ade22012-09-07 18:16:38 +00001849static void emitGlobalConstantImpl(const Constant *CV, unsigned AddrSpace,
Chris Lattner44e05082010-04-20 06:20:21 +00001850 AsmPrinter &AP) {
Micah Villmow3574eca2012-10-08 16:38:25 +00001851 const DataLayout *TD = AP.TM.getDataLayout();
Bill Wendling21e42d02012-03-20 08:56:43 +00001852 uint64_t Size = TD->getTypeAllocSize(CV->getType());
1853 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
Chris Lattner44e05082010-04-20 06:20:21 +00001854 return AP.OutStreamer.EmitZeros(Size, AddrSpace);
Chris Lattner2dd245c2010-01-20 07:11:32 +00001855
1856 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
Chris Lattner2dd245c2010-01-20 07:11:32 +00001857 switch (Size) {
1858 case 1:
1859 case 2:
1860 case 4:
1861 case 8:
Chris Lattner44e05082010-04-20 06:20:21 +00001862 if (AP.isVerbose())
Benjamin Kramer41a96492011-11-05 08:57:40 +00001863 AP.OutStreamer.GetCommentOS() << format("0x%" PRIx64 "\n",
1864 CI->getZExtValue());
Bill Wendling3d7ff082010-08-18 18:41:13 +00001865 AP.OutStreamer.EmitIntValue(CI->getZExtValue(), Size, AddrSpace);
Chris Lattner2dd245c2010-01-20 07:11:32 +00001866 return;
1867 default:
Chad Rosierc53ade22012-09-07 18:16:38 +00001868 emitGlobalConstantLargeInt(CI, AddrSpace, AP);
Chris Lattner2dd245c2010-01-20 07:11:32 +00001869 return;
1870 }
1871 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001872
Chris Lattner91093ec2010-01-19 19:10:44 +00001873 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV))
Chad Rosierc53ade22012-09-07 18:16:38 +00001874 return emitGlobalConstantFP(CFP, AddrSpace, AP);
Chris Lattner1b7e2352004-08-17 06:36:49 +00001875
Chris Lattnerb0bedd62010-01-20 17:57:50 +00001876 if (isa<ConstantPointerNull>(CV)) {
Chris Lattner44e05082010-04-20 06:20:21 +00001877 AP.OutStreamer.EmitIntValue(0, Size, AddrSpace);
Chris Lattnerb0bedd62010-01-20 17:57:50 +00001878 return;
1879 }
Jim Grosbach83d80832011-03-29 23:20:22 +00001880
Chris Lattner9e631da2012-01-24 09:31:43 +00001881 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
Chad Rosierc53ade22012-09-07 18:16:38 +00001882 return emitGlobalConstantDataSequential(CDS, AddrSpace, AP);
Chris Lattner9e631da2012-01-24 09:31:43 +00001883
1884 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
Chad Rosierc53ade22012-09-07 18:16:38 +00001885 return emitGlobalConstantArray(CVA, AddrSpace, AP);
Jim Grosbach83d80832011-03-29 23:20:22 +00001886
Chris Lattner9e631da2012-01-24 09:31:43 +00001887 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
Chad Rosierc53ade22012-09-07 18:16:38 +00001888 return emitGlobalConstantStruct(CVS, AddrSpace, AP);
Chris Lattner9e631da2012-01-24 09:31:43 +00001889
Bill Wendling21e42d02012-03-20 08:56:43 +00001890 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1891 // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of
1892 // vectors).
Chris Lattner9e631da2012-01-24 09:31:43 +00001893 if (CE->getOpcode() == Instruction::BitCast)
Chad Rosierc53ade22012-09-07 18:16:38 +00001894 return emitGlobalConstantImpl(CE->getOperand(0), AddrSpace, AP);
Bill Wendling21e42d02012-03-20 08:56:43 +00001895
1896 if (Size > 8) {
1897 // If the constant expression's size is greater than 64-bits, then we have
1898 // to emit the value in chunks. Try to constant fold the value and emit it
1899 // that way.
1900 Constant *New = ConstantFoldConstantExpression(CE, TD);
1901 if (New && New != CE)
Chad Rosierc53ade22012-09-07 18:16:38 +00001902 return emitGlobalConstantImpl(New, AddrSpace, AP);
Bill Wendling21e42d02012-03-20 08:56:43 +00001903 }
1904 }
Chris Lattner9e631da2012-01-24 09:31:43 +00001905
1906 if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))
Chad Rosierc53ade22012-09-07 18:16:38 +00001907 return emitGlobalConstantVector(V, AddrSpace, AP);
Chris Lattner9e631da2012-01-24 09:31:43 +00001908
Chris Lattner52492ac2010-01-23 06:17:14 +00001909 // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it
1910 // thread the streamer with EmitValue.
Chad Rosierc53ade22012-09-07 18:16:38 +00001911 AP.OutStreamer.EmitValue(lowerConstant(CV, AP), Size, AddrSpace);
Chris Lattner44e05082010-04-20 06:20:21 +00001912}
1913
1914/// EmitGlobalConstant - Print a general LLVM constant to the .s file.
1915void AsmPrinter::EmitGlobalConstant(const Constant *CV, unsigned AddrSpace) {
Micah Villmow3574eca2012-10-08 16:38:25 +00001916 uint64_t Size = TM.getDataLayout()->getTypeAllocSize(CV->getType());
Chris Lattner44e05082010-04-20 06:20:21 +00001917 if (Size)
Chad Rosierc53ade22012-09-07 18:16:38 +00001918 emitGlobalConstantImpl(CV, AddrSpace, *this);
Chris Lattner44e05082010-04-20 06:20:21 +00001919 else if (MAI->hasSubsectionsViaSymbols()) {
1920 // If the global has zero size, emit a single byte so that two labels don't
1921 // look like they are at the same location.
1922 OutStreamer.EmitIntValue(0, 1, AddrSpace);
1923 }
Chris Lattner1b7e2352004-08-17 06:36:49 +00001924}
Chris Lattner0264d1a2006-01-27 02:10:10 +00001925
Chris Lattnerfad86b02008-08-17 07:19:36 +00001926void AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {
Evan Chengd6594ae2006-09-12 21:00:35 +00001927 // Target doesn't support this yet!
Torok Edwinc23197a2009-07-14 16:55:14 +00001928 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");
Evan Chengd6594ae2006-09-12 21:00:35 +00001929}
1930
Chris Lattnerdfa107e2010-04-04 18:16:38 +00001931void AsmPrinter::printOffset(int64_t Offset, raw_ostream &OS) const {
1932 if (Offset > 0)
1933 OS << '+' << Offset;
1934 else if (Offset < 0)
1935 OS << Offset;
1936}
1937
Chris Lattnerc0215722010-04-04 19:25:43 +00001938//===----------------------------------------------------------------------===//
1939// Symbol Lowering Routines.
1940//===----------------------------------------------------------------------===//
1941
1942/// GetTempSymbol - Return the MCSymbol corresponding to the assembler
1943/// temporary label with the specified stem and unique ID.
1944MCSymbol *AsmPrinter::GetTempSymbol(StringRef Name, unsigned ID) const {
Chris Lattneraf8df262010-04-04 19:28:59 +00001945 return OutContext.GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) +
Chris Lattnerc0215722010-04-04 19:25:43 +00001946 Name + Twine(ID));
1947}
1948
1949/// GetTempSymbol - Return an assembler temporary label with the specified
1950/// stem.
1951MCSymbol *AsmPrinter::GetTempSymbol(StringRef Name) const {
1952 return OutContext.GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix())+
1953 Name);
1954}
1955
Chris Lattner66099132006-02-01 22:41:11 +00001956
Chris Lattner95175542010-02-08 23:10:08 +00001957MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const {
Chris Lattner3b9d6212010-03-14 17:53:23 +00001958 return MMI->getAddrLabelSymbol(BA->getBasicBlock());
Dan Gohman8c2b5252009-10-30 01:27:03 +00001959}
1960
Chris Lattner3b9d6212010-03-14 17:53:23 +00001961MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const {
1962 return MMI->getAddrLabelSymbol(BB);
Dan Gohman8c2b5252009-10-30 01:27:03 +00001963}
1964
Chris Lattner39248682010-01-23 05:19:23 +00001965/// GetCPISymbol - Return the symbol for the specified constant pool entry.
1966MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const {
Chris Lattner9b97a732010-03-30 18:10:53 +00001967 return OutContext.GetOrCreateSymbol
Chris Lattner98cdab52010-03-10 02:25:11 +00001968 (Twine(MAI->getPrivateGlobalPrefix()) + "CPI" + Twine(getFunctionNumber())
1969 + "_" + Twine(CPID));
Chris Lattner39248682010-01-23 05:19:23 +00001970}
1971
1972/// GetJTISymbol - Return the symbol for the specified jump table entry.
Bill Wendling07d31772010-06-29 22:34:52 +00001973MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const {
1974 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate);
Chris Lattner7cb384d2009-09-12 23:02:08 +00001975}
1976
Chris Lattner798d1252010-01-25 21:17:10 +00001977/// GetJTSetSymbol - Return the symbol for the specified jump table .set
1978/// FIXME: privatize to AsmPrinter.
1979MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const {
Chris Lattner9b97a732010-03-30 18:10:53 +00001980 return OutContext.GetOrCreateSymbol
Chris Lattner98cdab52010-03-10 02:25:11 +00001981 (Twine(MAI->getPrivateGlobalPrefix()) + Twine(getFunctionNumber()) + "_" +
1982 Twine(UID) + "_set_" + Twine(MBBID));
Chris Lattner798d1252010-01-25 21:17:10 +00001983}
1984
Chris Lattner7a2ba942010-01-16 18:37:32 +00001985/// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with
Chris Lattnerd588b972010-01-15 23:25:11 +00001986/// global value name as its base, with the specified suffix, and where the
Chris Lattner7a2ba942010-01-16 18:37:32 +00001987/// symbol is forced to have private linkage if ForcePrivate is true.
1988MCSymbol *AsmPrinter::GetSymbolWithGlobalValueBase(const GlobalValue *GV,
1989 StringRef Suffix,
1990 bool ForcePrivate) const {
Chris Lattnerd588b972010-01-15 23:25:11 +00001991 SmallString<60> NameStr;
Chris Lattner7a2ba942010-01-16 18:37:32 +00001992 Mang->getNameWithPrefix(NameStr, GV, ForcePrivate);
Chris Lattnerd588b972010-01-15 23:25:11 +00001993 NameStr.append(Suffix.begin(), Suffix.end());
Chris Lattner9b97a732010-03-30 18:10:53 +00001994 return OutContext.GetOrCreateSymbol(NameStr.str());
Chris Lattnerd588b972010-01-15 23:25:11 +00001995}
1996
Chris Lattner6b04ede2010-01-15 23:18:17 +00001997/// GetExternalSymbolSymbol - Return the MCSymbol for the specified
1998/// ExternalSymbol.
1999MCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const {
2000 SmallString<60> NameStr;
2001 Mang->getNameWithPrefix(NameStr, Sym);
2002 return OutContext.GetOrCreateSymbol(NameStr.str());
Jim Grosbach83d80832011-03-29 23:20:22 +00002003}
Chris Lattner6b04ede2010-01-15 23:18:17 +00002004
Chris Lattner7cb384d2009-09-12 23:02:08 +00002005
Chris Lattner523a5082010-01-22 21:50:41 +00002006
2007/// PrintParentLoopComment - Print comments about parent loops of this one.
2008static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop,
2009 unsigned FunctionNumber) {
2010 if (Loop == 0) return;
2011 PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber);
2012 OS.indent(Loop->getLoopDepth()*2)
2013 << "Parent Loop BB" << FunctionNumber << "_"
2014 << Loop->getHeader()->getNumber()
2015 << " Depth=" << Loop->getLoopDepth() << '\n';
2016}
2017
2018
2019/// PrintChildLoopComment - Print comments about child loops within
2020/// the loop for this basic block, with nesting.
2021static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop,
2022 unsigned FunctionNumber) {
2023 // Add child loop information
2024 for (MachineLoop::iterator CL = Loop->begin(), E = Loop->end();CL != E; ++CL){
2025 OS.indent((*CL)->getLoopDepth()*2)
2026 << "Child Loop BB" << FunctionNumber << "_"
2027 << (*CL)->getHeader()->getNumber() << " Depth " << (*CL)->getLoopDepth()
2028 << '\n';
2029 PrintChildLoopComment(OS, *CL, FunctionNumber);
2030 }
2031}
2032
Chad Rosierc53ade22012-09-07 18:16:38 +00002033/// emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
2034static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB,
Chris Lattnerdfa107e2010-04-04 18:16:38 +00002035 const MachineLoopInfo *LI,
2036 const AsmPrinter &AP) {
Chris Lattner523a5082010-01-22 21:50:41 +00002037 // Add loop depth information
2038 const MachineLoop *Loop = LI->getLoopFor(&MBB);
2039 if (Loop == 0) return;
Jim Grosbach83d80832011-03-29 23:20:22 +00002040
Chris Lattner523a5082010-01-22 21:50:41 +00002041 MachineBasicBlock *Header = Loop->getHeader();
2042 assert(Header && "No header for loop");
Jim Grosbach83d80832011-03-29 23:20:22 +00002043
Chris Lattner523a5082010-01-22 21:50:41 +00002044 // If this block is not a loop header, just print out what is the loop header
2045 // and return.
2046 if (Header != &MBB) {
2047 AP.OutStreamer.AddComment(" in Loop: Header=BB" +
2048 Twine(AP.getFunctionNumber())+"_" +
2049 Twine(Loop->getHeader()->getNumber())+
2050 " Depth="+Twine(Loop->getLoopDepth()));
2051 return;
2052 }
Jim Grosbach83d80832011-03-29 23:20:22 +00002053
Chris Lattner523a5082010-01-22 21:50:41 +00002054 // Otherwise, it is a loop header. Print out information about child and
2055 // parent loops.
2056 raw_ostream &OS = AP.OutStreamer.GetCommentOS();
Jim Grosbach83d80832011-03-29 23:20:22 +00002057
2058 PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber());
2059
Chris Lattner523a5082010-01-22 21:50:41 +00002060 OS << "=>";
2061 OS.indent(Loop->getLoopDepth()*2-2);
Jim Grosbach83d80832011-03-29 23:20:22 +00002062
Chris Lattner523a5082010-01-22 21:50:41 +00002063 OS << "This ";
2064 if (Loop->empty())
2065 OS << "Inner ";
2066 OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n';
Jim Grosbach83d80832011-03-29 23:20:22 +00002067
Chris Lattner523a5082010-01-22 21:50:41 +00002068 PrintChildLoopComment(OS, Loop, AP.getFunctionNumber());
2069}
2070
2071
Chris Lattner70a54c02009-09-13 18:25:37 +00002072/// EmitBasicBlockStart - This method prints the label for the specified
2073/// MachineBasicBlock, an alignment (if present) and a comment describing
2074/// it if appropriate.
Chris Lattner662316c2009-09-14 03:15:54 +00002075void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock *MBB) const {
Dan Gohmanb1cac332009-10-30 01:34:35 +00002076 // Emit an alignment directive for this block, if needed.
Chris Lattner70a54c02009-09-13 18:25:37 +00002077 if (unsigned Align = MBB->getAlignment())
Jakob Stoklund Olesen8c741b82011-12-06 01:26:19 +00002078 EmitAlignment(Align);
Evan Chengfb8075d2008-02-28 00:43:03 +00002079
Chris Lattner999aee22010-03-16 00:29:39 +00002080 // If the block has its address taken, emit any labels that were used to
2081 // reference the block. It is possible that there is more than one label
2082 // here, because multiple LLVM BB's may have been RAUW'd to this block after
2083 // the references were generated.
Dan Gohman8c2b5252009-10-30 01:27:03 +00002084 if (MBB->hasAddressTaken()) {
Chris Lattner213168b2010-01-20 07:24:05 +00002085 const BasicBlock *BB = MBB->getBasicBlock();
Chris Lattner3f53c832010-04-04 18:52:31 +00002086 if (isVerbose())
Chris Lattner999aee22010-03-16 00:29:39 +00002087 OutStreamer.AddComment("Block address taken");
Jim Grosbach83d80832011-03-29 23:20:22 +00002088
Chris Lattner999aee22010-03-16 00:29:39 +00002089 std::vector<MCSymbol*> Syms = MMI->getAddrLabelSymbolToEmit(BB);
2090
2091 for (unsigned i = 0, e = Syms.size(); i != e; ++i)
2092 OutStreamer.EmitLabel(Syms[i]);
Dan Gohman8c2b5252009-10-30 01:27:03 +00002093 }
2094
Jakob Stoklund Olesenc511c282012-03-06 22:27:13 +00002095 // Print some verbose block comments.
2096 if (isVerbose()) {
2097 if (const BasicBlock *BB = MBB->getBasicBlock())
2098 if (BB->hasName())
2099 OutStreamer.AddComment("%" + BB->getName());
Chad Rosierc53ade22012-09-07 18:16:38 +00002100 emitBasicBlockLoopComments(*MBB, LI, *this);
Jakob Stoklund Olesenc511c282012-03-06 22:27:13 +00002101 }
2102
Dan Gohmanb1cac332009-10-30 01:34:35 +00002103 // Print the main label for the block.
Chris Lattner0a3f3992010-02-17 18:52:56 +00002104 if (MBB->pred_empty() || isBlockOnlyReachableByFallthrough(MBB)) {
Chris Lattner3f53c832010-04-04 18:52:31 +00002105 if (isVerbose() && OutStreamer.hasRawTextSupport()) {
Chris Lattner58bc4dd2010-04-03 22:12:35 +00002106 // NOTE: Want this comment at start of line, don't emit with AddComment.
2107 OutStreamer.EmitRawText(Twine(MAI->getCommentString()) + " BB#" +
2108 Twine(MBB->getNumber()) + ":");
Chris Lattner0fd90fd2010-01-22 19:52:01 +00002109 }
Dan Gohmane3cc3f32009-10-06 17:38:38 +00002110 } else {
Chris Lattner1b2eb0e2010-03-13 21:04:28 +00002111 OutStreamer.EmitLabel(MBB->getSymbol());
Dan Gohmane3cc3f32009-10-06 17:38:38 +00002112 }
Nate Begeman37efe672006-04-22 18:53:45 +00002113}
Nate Begeman52a51e382006-08-12 21:29:52 +00002114
Stuart Hastings5129bde2011-02-23 02:27:05 +00002115void AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility,
2116 bool IsDefinition) const {
Chris Lattner152a29b2010-01-23 06:53:23 +00002117 MCSymbolAttr Attr = MCSA_Invalid;
Jim Grosbach83d80832011-03-29 23:20:22 +00002118
Chris Lattner152a29b2010-01-23 06:53:23 +00002119 switch (Visibility) {
2120 default: break;
2121 case GlobalValue::HiddenVisibility:
Stuart Hastings5129bde2011-02-23 02:27:05 +00002122 if (IsDefinition)
2123 Attr = MAI->getHiddenVisibilityAttr();
2124 else
2125 Attr = MAI->getHiddenDeclarationVisibilityAttr();
Chris Lattner152a29b2010-01-23 06:53:23 +00002126 break;
2127 case GlobalValue::ProtectedVisibility:
2128 Attr = MAI->getProtectedVisibilityAttr();
2129 break;
Chris Lattner53d4d782010-01-15 23:38:51 +00002130 }
Chris Lattner152a29b2010-01-23 06:53:23 +00002131
2132 if (Attr != MCSA_Invalid)
2133 OutStreamer.EmitSymbolAttribute(Sym, Attr);
Chris Lattner53d4d782010-01-15 23:38:51 +00002134}
2135
Chris Lattner0a3f3992010-02-17 18:52:56 +00002136/// isBlockOnlyReachableByFallthough - Return true if the basic block has
2137/// exactly one predecessor and the control transfer mechanism between
2138/// the predecessor and this block is a fall-through.
Chris Lattnere00b59f2010-04-04 17:57:56 +00002139bool AsmPrinter::
2140isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const {
Chris Lattner0a3f3992010-02-17 18:52:56 +00002141 // If this is a landing pad, it isn't a fall through. If it has no preds,
2142 // then nothing falls through to it.
2143 if (MBB->isLandingPad() || MBB->pred_empty())
2144 return false;
Jim Grosbach83d80832011-03-29 23:20:22 +00002145
Chris Lattner0a3f3992010-02-17 18:52:56 +00002146 // If there isn't exactly one predecessor, it can't be a fall through.
2147 MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(), PI2 = PI;
2148 ++PI2;
2149 if (PI2 != MBB->pred_end())
2150 return false;
Jim Grosbach83d80832011-03-29 23:20:22 +00002151
Chris Lattner0a3f3992010-02-17 18:52:56 +00002152 // The predecessor has to be immediately before this block.
Eli Friedman0fc30152011-06-14 19:30:33 +00002153 MachineBasicBlock *Pred = *PI;
Jim Grosbach83d80832011-03-29 23:20:22 +00002154
Chris Lattner0a3f3992010-02-17 18:52:56 +00002155 if (!Pred->isLayoutSuccessor(MBB))
2156 return false;
Jim Grosbach83d80832011-03-29 23:20:22 +00002157
Chris Lattner0a3f3992010-02-17 18:52:56 +00002158 // If the block is completely empty, then it definitely does fall through.
2159 if (Pred->empty())
2160 return true;
Jim Grosbach83d80832011-03-29 23:20:22 +00002161
Eli Friedman0fc30152011-06-14 19:30:33 +00002162 // Check the terminators in the previous blocks
2163 for (MachineBasicBlock::iterator II = Pred->getFirstTerminator(),
2164 IE = Pred->end(); II != IE; ++II) {
2165 MachineInstr &MI = *II;
2166
2167 // If it is not a simple branch, we are in a table somewhere.
Evan Cheng5a96b3d2011-12-07 07:15:52 +00002168 if (!MI.isBranch() || MI.isIndirectBranch())
Eli Friedman0fc30152011-06-14 19:30:33 +00002169 return false;
2170
2171 // If we are the operands of one of the branches, this is not
2172 // a fall through.
2173 for (MachineInstr::mop_iterator OI = MI.operands_begin(),
2174 OE = MI.operands_end(); OI != OE; ++OI) {
2175 const MachineOperand& OP = *OI;
Rafael Espindolaaeb6da42011-06-15 21:00:28 +00002176 if (OP.isJTI())
2177 return false;
Eli Friedman0fc30152011-06-14 19:30:33 +00002178 if (OP.isMBB() && OP.getMBB() == MBB)
2179 return false;
2180 }
2181 }
2182
2183 return true;
Chris Lattner0a3f3992010-02-17 18:52:56 +00002184}
2185
2186
2187
Gordon Henriksen5eca0752008-08-17 18:44:35 +00002188GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) {
2189 if (!S->usesMetadata())
Gordon Henriksenc317a602008-08-17 12:08:44 +00002190 return 0;
Chris Lattnere00b59f2010-04-04 17:57:56 +00002191
2192 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters);
2193 gcp_map_type::iterator GCPI = GCMap.find(S);
2194 if (GCPI != GCMap.end())
Gordon Henriksenc317a602008-08-17 12:08:44 +00002195 return GCPI->second;
Jim Grosbach83d80832011-03-29 23:20:22 +00002196
Gordon Henriksen5eca0752008-08-17 18:44:35 +00002197 const char *Name = S->getName().c_str();
Jim Grosbach83d80832011-03-29 23:20:22 +00002198
Gordon Henriksenc317a602008-08-17 12:08:44 +00002199 for (GCMetadataPrinterRegistry::iterator
2200 I = GCMetadataPrinterRegistry::begin(),
2201 E = GCMetadataPrinterRegistry::end(); I != E; ++I)
2202 if (strcmp(Name, I->getName()) == 0) {
Gordon Henriksen5eca0752008-08-17 18:44:35 +00002203 GCMetadataPrinter *GMP = I->instantiate();
2204 GMP->S = S;
Chris Lattnere00b59f2010-04-04 17:57:56 +00002205 GCMap.insert(std::make_pair(S, GMP));
Gordon Henriksen5eca0752008-08-17 18:44:35 +00002206 return GMP;
Gordon Henriksenc317a602008-08-17 12:08:44 +00002207 }
Jim Grosbach83d80832011-03-29 23:20:22 +00002208
Chris Lattner75361b62010-04-07 22:58:41 +00002209 report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name));
Gordon Henriksenc317a602008-08-17 12:08:44 +00002210}