File: | lib/CodeGen/AsmPrinter/AsmPrinter.cpp |
Location: | line 1496, column 37 |
Description: | The result of the '<<' expression is undefined |
1 | //===-- AsmPrinter.cpp - Common AsmPrinter code ---------------------------===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This file implements the AsmPrinter class. | |||
11 | // | |||
12 | //===----------------------------------------------------------------------===// | |||
13 | ||||
14 | #include "llvm/CodeGen/AsmPrinter.h" | |||
15 | #include "DwarfDebug.h" | |||
16 | #include "DwarfException.h" | |||
17 | #include "Win64Exception.h" | |||
18 | #include "WinCodeViewLineTables.h" | |||
19 | #include "llvm/ADT/SmallString.h" | |||
20 | #include "llvm/ADT/Statistic.h" | |||
21 | #include "llvm/Analysis/ConstantFolding.h" | |||
22 | #include "llvm/Analysis/JumpInstrTableInfo.h" | |||
23 | #include "llvm/CodeGen/Analysis.h" | |||
24 | #include "llvm/CodeGen/GCMetadataPrinter.h" | |||
25 | #include "llvm/CodeGen/MachineConstantPool.h" | |||
26 | #include "llvm/CodeGen/MachineFrameInfo.h" | |||
27 | #include "llvm/CodeGen/MachineFunction.h" | |||
28 | #include "llvm/CodeGen/MachineInstrBundle.h" | |||
29 | #include "llvm/CodeGen/MachineJumpTableInfo.h" | |||
30 | #include "llvm/CodeGen/MachineLoopInfo.h" | |||
31 | #include "llvm/CodeGen/MachineModuleInfo.h" | |||
32 | #include "llvm/IR/DataLayout.h" | |||
33 | #include "llvm/IR/DebugInfo.h" | |||
34 | #include "llvm/IR/Mangler.h" | |||
35 | #include "llvm/IR/Module.h" | |||
36 | #include "llvm/IR/Operator.h" | |||
37 | #include "llvm/MC/MCAsmInfo.h" | |||
38 | #include "llvm/MC/MCContext.h" | |||
39 | #include "llvm/MC/MCExpr.h" | |||
40 | #include "llvm/MC/MCInst.h" | |||
41 | #include "llvm/MC/MCSection.h" | |||
42 | #include "llvm/MC/MCStreamer.h" | |||
43 | #include "llvm/MC/MCSymbol.h" | |||
44 | #include "llvm/Support/ErrorHandling.h" | |||
45 | #include "llvm/Support/Format.h" | |||
46 | #include "llvm/Support/MathExtras.h" | |||
47 | #include "llvm/Support/Timer.h" | |||
48 | #include "llvm/Target/TargetFrameLowering.h" | |||
49 | #include "llvm/Target/TargetInstrInfo.h" | |||
50 | #include "llvm/Target/TargetLowering.h" | |||
51 | #include "llvm/Target/TargetLoweringObjectFile.h" | |||
52 | #include "llvm/Target/TargetRegisterInfo.h" | |||
53 | #include "llvm/Target/TargetSubtargetInfo.h" | |||
54 | using namespace llvm; | |||
55 | ||||
56 | #define DEBUG_TYPE"asm-printer" "asm-printer" | |||
57 | ||||
58 | static const char *const DWARFGroupName = "DWARF Emission"; | |||
59 | static const char *const DbgTimerName = "Debug Info Emission"; | |||
60 | static const char *const EHTimerName = "DWARF Exception Writer"; | |||
61 | static const char *const CodeViewLineTablesGroupName = "CodeView Line Tables"; | |||
62 | ||||
63 | STATISTIC(EmittedInsts, "Number of machine instrs printed")static llvm::Statistic EmittedInsts = { "asm-printer", "Number of machine instrs printed" , 0, 0 }; | |||
64 | ||||
65 | char AsmPrinter::ID = 0; | |||
66 | ||||
67 | typedef DenseMap<GCStrategy*, std::unique_ptr<GCMetadataPrinter>> gcp_map_type; | |||
68 | static gcp_map_type &getGCMap(void *&P) { | |||
69 | if (!P) | |||
70 | P = new gcp_map_type(); | |||
71 | return *(gcp_map_type*)P; | |||
72 | } | |||
73 | ||||
74 | ||||
75 | /// getGVAlignmentLog2 - Return the alignment to use for the specified global | |||
76 | /// value in log2 form. This rounds up to the preferred alignment if possible | |||
77 | /// and legal. | |||
78 | static unsigned getGVAlignmentLog2(const GlobalValue *GV, const DataLayout &TD, | |||
79 | unsigned InBits = 0) { | |||
80 | unsigned NumBits = 0; | |||
81 | if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) | |||
82 | NumBits = TD.getPreferredAlignmentLog(GVar); | |||
83 | ||||
84 | // If InBits is specified, round it to it. | |||
85 | if (InBits > NumBits) | |||
86 | NumBits = InBits; | |||
87 | ||||
88 | // If the GV has a specified alignment, take it into account. | |||
89 | if (GV->getAlignment() == 0) | |||
90 | return NumBits; | |||
91 | ||||
92 | unsigned GVAlign = Log2_32(GV->getAlignment()); | |||
93 | ||||
94 | // If the GVAlign is larger than NumBits, or if we are required to obey | |||
95 | // NumBits because the GV has an assigned section, obey it. | |||
96 | if (GVAlign > NumBits || GV->hasSection()) | |||
97 | NumBits = GVAlign; | |||
98 | return NumBits; | |||
99 | } | |||
100 | ||||
101 | AsmPrinter::AsmPrinter(TargetMachine &tm, MCStreamer &Streamer) | |||
102 | : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()), | |||
103 | MII(tm.getSubtargetImpl()->getInstrInfo()), | |||
104 | OutContext(Streamer.getContext()), OutStreamer(Streamer), LastMI(nullptr), | |||
105 | LastFn(0), Counter(~0U), SetCounter(0) { | |||
106 | DD = nullptr; MMI = nullptr; LI = nullptr; MF = nullptr; | |||
107 | CurrentFnSym = CurrentFnSymForSize = nullptr; | |||
108 | GCMetadataPrinters = nullptr; | |||
109 | VerboseAsm = Streamer.isVerboseAsm(); | |||
110 | } | |||
111 | ||||
112 | AsmPrinter::~AsmPrinter() { | |||
113 | assert(!DD && Handlers.empty() && "Debug/EH info didn't get finalized")((!DD && Handlers.empty() && "Debug/EH info didn't get finalized" ) ? static_cast<void> (0) : __assert_fail ("!DD && Handlers.empty() && \"Debug/EH info didn't get finalized\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 113, __PRETTY_FUNCTION__)); | |||
114 | ||||
115 | if (GCMetadataPrinters) { | |||
116 | gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); | |||
117 | ||||
118 | delete &GCMap; | |||
119 | GCMetadataPrinters = nullptr; | |||
120 | } | |||
121 | ||||
122 | delete &OutStreamer; | |||
123 | } | |||
124 | ||||
125 | /// getFunctionNumber - Return a unique ID for the current function. | |||
126 | /// | |||
127 | unsigned AsmPrinter::getFunctionNumber() const { | |||
128 | return MF->getFunctionNumber(); | |||
129 | } | |||
130 | ||||
131 | const TargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { | |||
132 | return TM.getSubtargetImpl()->getTargetLowering()->getObjFileLowering(); | |||
133 | } | |||
134 | ||||
135 | /// getDataLayout - Return information about data layout. | |||
136 | const DataLayout &AsmPrinter::getDataLayout() const { | |||
137 | return *TM.getSubtargetImpl()->getDataLayout(); | |||
138 | } | |||
139 | ||||
140 | const MCSubtargetInfo &AsmPrinter::getSubtargetInfo() const { | |||
141 | return TM.getSubtarget<MCSubtargetInfo>(); | |||
142 | } | |||
143 | ||||
144 | void AsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) { | |||
145 | S.EmitInstruction(Inst, getSubtargetInfo()); | |||
146 | } | |||
147 | ||||
148 | StringRef AsmPrinter::getTargetTriple() const { | |||
149 | return TM.getTargetTriple(); | |||
150 | } | |||
151 | ||||
152 | /// getCurrentSection() - Return the current section we are emitting to. | |||
153 | const MCSection *AsmPrinter::getCurrentSection() const { | |||
154 | return OutStreamer.getCurrentSection().first; | |||
155 | } | |||
156 | ||||
157 | ||||
158 | ||||
159 | void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { | |||
160 | AU.setPreservesAll(); | |||
161 | MachineFunctionPass::getAnalysisUsage(AU); | |||
162 | AU.addRequired<MachineModuleInfo>(); | |||
163 | AU.addRequired<GCModuleInfo>(); | |||
164 | if (isVerbose()) | |||
165 | AU.addRequired<MachineLoopInfo>(); | |||
166 | } | |||
167 | ||||
168 | bool AsmPrinter::doInitialization(Module &M) { | |||
169 | MMI = getAnalysisIfAvailable<MachineModuleInfo>(); | |||
170 | MMI->AnalyzeModule(M); | |||
171 | ||||
172 | // Initialize TargetLoweringObjectFile. | |||
173 | const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) | |||
174 | .Initialize(OutContext, TM); | |||
175 | ||||
176 | OutStreamer.InitSections(false); | |||
177 | ||||
178 | Mang = new Mangler(TM.getSubtargetImpl()->getDataLayout()); | |||
179 | ||||
180 | // Emit the version-min deplyment target directive if needed. | |||
181 | // | |||
182 | // FIXME: If we end up with a collection of these sorts of Darwin-specific | |||
183 | // or ELF-specific things, it may make sense to have a platform helper class | |||
184 | // that will work with the target helper class. For now keep it here, as the | |||
185 | // alternative is duplicated code in each of the target asm printers that | |||
186 | // use the directive, where it would need the same conditionalization | |||
187 | // anyway. | |||
188 | Triple TT(getTargetTriple()); | |||
189 | if (TT.isOSDarwin()) { | |||
190 | unsigned Major, Minor, Update; | |||
191 | TT.getOSVersion(Major, Minor, Update); | |||
192 | // If there is a version specified, Major will be non-zero. | |||
193 | if (Major) | |||
194 | OutStreamer.EmitVersionMin((TT.isMacOSX() ? | |||
195 | MCVM_OSXVersionMin : MCVM_IOSVersionMin), | |||
196 | Major, Minor, Update); | |||
197 | } | |||
198 | ||||
199 | // Allow the target to emit any magic that it wants at the start of the file. | |||
200 | EmitStartOfAsmFile(M); | |||
201 | ||||
202 | // Very minimal debug info. It is ignored if we emit actual debug info. If we | |||
203 | // don't, this at least helps the user find where a global came from. | |||
204 | if (MAI->hasSingleParameterDotFile()) { | |||
205 | // .file "foo.c" | |||
206 | OutStreamer.EmitFileDirective(M.getModuleIdentifier()); | |||
207 | } | |||
208 | ||||
209 | GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); | |||
210 | assert(MI && "AsmPrinter didn't require GCModuleInfo?")((MI && "AsmPrinter didn't require GCModuleInfo?") ? static_cast <void> (0) : __assert_fail ("MI && \"AsmPrinter didn't require GCModuleInfo?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 210, __PRETTY_FUNCTION__)); | |||
211 | for (auto &I : *MI) | |||
212 | if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) | |||
213 | MP->beginAssembly(M, *MI, *this); | |||
214 | ||||
215 | // Emit module-level inline asm if it exists. | |||
216 | if (!M.getModuleInlineAsm().empty()) { | |||
217 | OutStreamer.AddComment("Start of file scope inline assembly"); | |||
218 | OutStreamer.AddBlankLine(); | |||
219 | EmitInlineAsm(M.getModuleInlineAsm()+"\n"); | |||
220 | OutStreamer.AddComment("End of file scope inline assembly"); | |||
221 | OutStreamer.AddBlankLine(); | |||
222 | } | |||
223 | ||||
224 | if (MAI->doesSupportDebugInformation()) { | |||
225 | if (Triple(TM.getTargetTriple()).isKnownWindowsMSVCEnvironment()) | |||
226 | Handlers.push_back(HandlerInfo(new WinCodeViewLineTables(this), | |||
227 | DbgTimerName, | |||
228 | CodeViewLineTablesGroupName)); | |||
229 | DD = new DwarfDebug(this, &M); | |||
230 | Handlers.push_back(HandlerInfo(DD, DbgTimerName, DWARFGroupName)); | |||
231 | } | |||
232 | ||||
233 | EHStreamer *ES = nullptr; | |||
234 | switch (MAI->getExceptionHandlingType()) { | |||
235 | case ExceptionHandling::None: | |||
236 | break; | |||
237 | case ExceptionHandling::SjLj: | |||
238 | case ExceptionHandling::DwarfCFI: | |||
239 | ES = new DwarfCFIException(this); | |||
240 | break; | |||
241 | case ExceptionHandling::ARM: | |||
242 | ES = new ARMException(this); | |||
243 | break; | |||
244 | case ExceptionHandling::ItaniumWinEH: | |||
245 | switch (MAI->getWinEHEncodingType()) { | |||
246 | default: llvm_unreachable("unsupported unwinding information encoding")::llvm::llvm_unreachable_internal("unsupported unwinding information encoding" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 246); | |||
247 | case WinEH::EncodingType::Itanium: | |||
248 | ES = new Win64Exception(this); | |||
249 | break; | |||
250 | } | |||
251 | break; | |||
252 | } | |||
253 | if (ES) | |||
254 | Handlers.push_back(HandlerInfo(ES, EHTimerName, DWARFGroupName)); | |||
255 | return false; | |||
256 | } | |||
257 | ||||
258 | static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) { | |||
259 | if (!MAI.hasWeakDefCanBeHiddenDirective()) | |||
260 | return false; | |||
261 | ||||
262 | return canBeOmittedFromSymbolTable(GV); | |||
263 | } | |||
264 | ||||
265 | void AsmPrinter::EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const { | |||
266 | GlobalValue::LinkageTypes Linkage = GV->getLinkage(); | |||
267 | switch (Linkage) { | |||
268 | case GlobalValue::CommonLinkage: | |||
269 | case GlobalValue::LinkOnceAnyLinkage: | |||
270 | case GlobalValue::LinkOnceODRLinkage: | |||
271 | case GlobalValue::WeakAnyLinkage: | |||
272 | case GlobalValue::WeakODRLinkage: | |||
273 | if (MAI->hasWeakDefDirective()) { | |||
274 | // .globl _foo | |||
275 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); | |||
276 | ||||
277 | if (!canBeHidden(GV, *MAI)) | |||
278 | // .weak_definition _foo | |||
279 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition); | |||
280 | else | |||
281 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate); | |||
282 | } else if (MAI->hasLinkOnceDirective()) { | |||
283 | // .globl _foo | |||
284 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); | |||
285 | //NOTE: linkonce is handled by the section the symbol was assigned to. | |||
286 | } else { | |||
287 | // .weak _foo | |||
288 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); | |||
289 | } | |||
290 | return; | |||
291 | case GlobalValue::AppendingLinkage: | |||
292 | // FIXME: appending linkage variables should go into a section of | |||
293 | // their name or something. For now, just emit them as external. | |||
294 | case GlobalValue::ExternalLinkage: | |||
295 | // If external or appending, declare as a global symbol. | |||
296 | // .globl _foo | |||
297 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); | |||
298 | return; | |||
299 | case GlobalValue::PrivateLinkage: | |||
300 | case GlobalValue::InternalLinkage: | |||
301 | return; | |||
302 | case GlobalValue::AvailableExternallyLinkage: | |||
303 | llvm_unreachable("Should never emit this")::llvm::llvm_unreachable_internal("Should never emit this", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 303); | |||
304 | case GlobalValue::ExternalWeakLinkage: | |||
305 | llvm_unreachable("Don't know how to emit these")::llvm::llvm_unreachable_internal("Don't know how to emit these" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 305); | |||
306 | } | |||
307 | llvm_unreachable("Unknown linkage type!")::llvm::llvm_unreachable_internal("Unknown linkage type!", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 307); | |||
308 | } | |||
309 | ||||
310 | void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name, | |||
311 | const GlobalValue *GV) const { | |||
312 | TM.getNameWithPrefix(Name, GV, *Mang); | |||
313 | } | |||
314 | ||||
315 | MCSymbol *AsmPrinter::getSymbol(const GlobalValue *GV) const { | |||
316 | return TM.getSymbol(GV, *Mang); | |||
317 | } | |||
318 | ||||
319 | /// EmitGlobalVariable - Emit the specified global variable to the .s file. | |||
320 | void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { | |||
321 | if (GV->hasInitializer()) { | |||
322 | // Check to see if this is a special global used by LLVM, if so, emit it. | |||
323 | if (EmitSpecialLLVMGlobal(GV)) | |||
324 | return; | |||
325 | ||||
326 | if (isVerbose()) { | |||
327 | GV->printAsOperand(OutStreamer.GetCommentOS(), | |||
328 | /*PrintType=*/false, GV->getParent()); | |||
329 | OutStreamer.GetCommentOS() << '\n'; | |||
330 | } | |||
331 | } | |||
332 | ||||
333 | MCSymbol *GVSym = getSymbol(GV); | |||
334 | EmitVisibility(GVSym, GV->getVisibility(), !GV->isDeclaration()); | |||
335 | ||||
336 | if (!GV->hasInitializer()) // External globals require no extra code. | |||
337 | return; | |||
338 | ||||
339 | if (MAI->hasDotTypeDotSizeDirective()) | |||
340 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); | |||
341 | ||||
342 | SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); | |||
343 | ||||
344 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
345 | uint64_t Size = DL->getTypeAllocSize(GV->getType()->getElementType()); | |||
346 | ||||
347 | // If the alignment is specified, we *must* obey it. Overaligning a global | |||
348 | // with a specified alignment is a prompt way to break globals emitted to | |||
349 | // sections and expected to be contiguous (e.g. ObjC metadata). | |||
350 | unsigned AlignLog = getGVAlignmentLog2(GV, *DL); | |||
351 | ||||
352 | for (const HandlerInfo &HI : Handlers) { | |||
353 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, TimePassesIsEnabled); | |||
354 | HI.Handler->setSymbolSize(GVSym, Size); | |||
355 | } | |||
356 | ||||
357 | // Handle common and BSS local symbols (.lcomm). | |||
358 | if (GVKind.isCommon() || GVKind.isBSSLocal()) { | |||
359 | if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. | |||
360 | unsigned Align = 1 << AlignLog; | |||
361 | ||||
362 | // Handle common symbols. | |||
363 | if (GVKind.isCommon()) { | |||
364 | if (!getObjFileLowering().getCommDirectiveSupportsAlignment()) | |||
365 | Align = 0; | |||
366 | ||||
367 | // .comm _foo, 42, 4 | |||
368 | OutStreamer.EmitCommonSymbol(GVSym, Size, Align); | |||
369 | return; | |||
370 | } | |||
371 | ||||
372 | // Handle local BSS symbols. | |||
373 | if (MAI->hasMachoZeroFillDirective()) { | |||
374 | const MCSection *TheSection = | |||
375 | getObjFileLowering().SectionForGlobal(GV, GVKind, *Mang, TM); | |||
376 | // .zerofill __DATA, __bss, _foo, 400, 5 | |||
377 | OutStreamer.EmitZerofill(TheSection, GVSym, Size, Align); | |||
378 | return; | |||
379 | } | |||
380 | ||||
381 | // Use .lcomm only if it supports user-specified alignment. | |||
382 | // Otherwise, while it would still be correct to use .lcomm in some | |||
383 | // cases (e.g. when Align == 1), the external assembler might enfore | |||
384 | // some -unknown- default alignment behavior, which could cause | |||
385 | // spurious differences between external and integrated assembler. | |||
386 | // Prefer to simply fall back to .local / .comm in this case. | |||
387 | if (MAI->getLCOMMDirectiveAlignmentType() != LCOMM::NoAlignment) { | |||
388 | // .lcomm _foo, 42 | |||
389 | OutStreamer.EmitLocalCommonSymbol(GVSym, Size, Align); | |||
390 | return; | |||
391 | } | |||
392 | ||||
393 | if (!getObjFileLowering().getCommDirectiveSupportsAlignment()) | |||
394 | Align = 0; | |||
395 | ||||
396 | // .local _foo | |||
397 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local); | |||
398 | // .comm _foo, 42, 4 | |||
399 | OutStreamer.EmitCommonSymbol(GVSym, Size, Align); | |||
400 | return; | |||
401 | } | |||
402 | ||||
403 | const MCSection *TheSection = | |||
404 | getObjFileLowering().SectionForGlobal(GV, GVKind, *Mang, TM); | |||
405 | ||||
406 | // Handle the zerofill directive on darwin, which is a special form of BSS | |||
407 | // emission. | |||
408 | if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) { | |||
409 | if (Size == 0) Size = 1; // zerofill of 0 bytes is undefined. | |||
410 | ||||
411 | // .globl _foo | |||
412 | OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); | |||
413 | // .zerofill __DATA, __common, _foo, 400, 5 | |||
414 | OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); | |||
415 | return; | |||
416 | } | |||
417 | ||||
418 | // Handle thread local data for mach-o which requires us to output an | |||
419 | // additional structure of data and mangle the original symbol so that we | |||
420 | // can reference it later. | |||
421 | // | |||
422 | // TODO: This should become an "emit thread local global" method on TLOF. | |||
423 | // All of this macho specific stuff should be sunk down into TLOFMachO and | |||
424 | // stuff like "TLSExtraDataSection" should no longer be part of the parent | |||
425 | // TLOF class. This will also make it more obvious that stuff like | |||
426 | // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho | |||
427 | // specific code. | |||
428 | if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) { | |||
429 | // Emit the .tbss symbol | |||
430 | MCSymbol *MangSym = | |||
431 | OutContext.GetOrCreateSymbol(GVSym->getName() + Twine("$tlv$init")); | |||
432 | ||||
433 | if (GVKind.isThreadBSS()) { | |||
434 | TheSection = getObjFileLowering().getTLSBSSSection(); | |||
435 | OutStreamer.EmitTBSSSymbol(TheSection, MangSym, Size, 1 << AlignLog); | |||
436 | } else if (GVKind.isThreadData()) { | |||
437 | OutStreamer.SwitchSection(TheSection); | |||
438 | ||||
439 | EmitAlignment(AlignLog, GV); | |||
440 | OutStreamer.EmitLabel(MangSym); | |||
441 | ||||
442 | EmitGlobalConstant(GV->getInitializer()); | |||
443 | } | |||
444 | ||||
445 | OutStreamer.AddBlankLine(); | |||
446 | ||||
447 | // Emit the variable struct for the runtime. | |||
448 | const MCSection *TLVSect | |||
449 | = getObjFileLowering().getTLSExtraDataSection(); | |||
450 | ||||
451 | OutStreamer.SwitchSection(TLVSect); | |||
452 | // Emit the linkage here. | |||
453 | EmitLinkage(GV, GVSym); | |||
454 | OutStreamer.EmitLabel(GVSym); | |||
455 | ||||
456 | // Three pointers in size: | |||
457 | // - __tlv_bootstrap - used to make sure support exists | |||
458 | // - spare pointer, used when mapped by the runtime | |||
459 | // - pointer to mangled symbol above with initializer | |||
460 | unsigned PtrSize = DL->getPointerTypeSize(GV->getType()); | |||
461 | OutStreamer.EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"), | |||
462 | PtrSize); | |||
463 | OutStreamer.EmitIntValue(0, PtrSize); | |||
464 | OutStreamer.EmitSymbolValue(MangSym, PtrSize); | |||
465 | ||||
466 | OutStreamer.AddBlankLine(); | |||
467 | return; | |||
468 | } | |||
469 | ||||
470 | OutStreamer.SwitchSection(TheSection); | |||
471 | ||||
472 | EmitLinkage(GV, GVSym); | |||
473 | EmitAlignment(AlignLog, GV); | |||
474 | ||||
475 | OutStreamer.EmitLabel(GVSym); | |||
476 | ||||
477 | EmitGlobalConstant(GV->getInitializer()); | |||
478 | ||||
479 | if (MAI->hasDotTypeDotSizeDirective()) | |||
480 | // .size foo, 42 | |||
481 | OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); | |||
482 | ||||
483 | OutStreamer.AddBlankLine(); | |||
484 | } | |||
485 | ||||
486 | /// EmitFunctionHeader - This method emits the header for the current | |||
487 | /// function. | |||
488 | void AsmPrinter::EmitFunctionHeader() { | |||
489 | // Print out constants referenced by the function | |||
490 | EmitConstantPool(); | |||
491 | ||||
492 | // Print the 'header' of function. | |||
493 | const Function *F = MF->getFunction(); | |||
494 | ||||
495 | OutStreamer.SwitchSection( | |||
496 | getObjFileLowering().SectionForGlobal(F, *Mang, TM)); | |||
497 | EmitVisibility(CurrentFnSym, F->getVisibility()); | |||
498 | ||||
499 | EmitLinkage(F, CurrentFnSym); | |||
500 | EmitAlignment(MF->getAlignment(), F); | |||
| ||||
501 | ||||
502 | if (MAI->hasDotTypeDotSizeDirective()) | |||
503 | OutStreamer.EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction); | |||
504 | ||||
505 | if (isVerbose()) { | |||
506 | F->printAsOperand(OutStreamer.GetCommentOS(), | |||
507 | /*PrintType=*/false, F->getParent()); | |||
508 | OutStreamer.GetCommentOS() << '\n'; | |||
509 | } | |||
510 | ||||
511 | // Emit the prefix data. | |||
512 | if (F->hasPrefixData()) | |||
513 | EmitGlobalConstant(F->getPrefixData()); | |||
514 | ||||
515 | // Emit the CurrentFnSym. This is a virtual function to allow targets to | |||
516 | // do their wild and crazy things as required. | |||
517 | EmitFunctionEntryLabel(); | |||
518 | ||||
519 | // If the function had address-taken blocks that got deleted, then we have | |||
520 | // references to the dangling symbols. Emit them at the start of the function | |||
521 | // so that we don't get references to undefined symbols. | |||
522 | std::vector<MCSymbol*> DeadBlockSyms; | |||
523 | MMI->takeDeletedSymbolsForFunction(F, DeadBlockSyms); | |||
524 | for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) { | |||
525 | OutStreamer.AddComment("Address taken block that was later removed"); | |||
526 | OutStreamer.EmitLabel(DeadBlockSyms[i]); | |||
527 | } | |||
528 | ||||
529 | // Emit pre-function debug and/or EH information. | |||
530 | for (const HandlerInfo &HI : Handlers) { | |||
531 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, TimePassesIsEnabled); | |||
532 | HI.Handler->beginFunction(MF); | |||
533 | } | |||
534 | ||||
535 | // Emit the prologue data. | |||
536 | if (F->hasPrologueData()) | |||
537 | EmitGlobalConstant(F->getPrologueData()); | |||
538 | } | |||
539 | ||||
540 | /// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the | |||
541 | /// function. This can be overridden by targets as required to do custom stuff. | |||
542 | void AsmPrinter::EmitFunctionEntryLabel() { | |||
543 | // The function label could have already been emitted if two symbols end up | |||
544 | // conflicting due to asm renaming. Detect this and emit an error. | |||
545 | if (CurrentFnSym->isUndefined()) | |||
546 | return OutStreamer.EmitLabel(CurrentFnSym); | |||
547 | ||||
548 | report_fatal_error("'" + Twine(CurrentFnSym->getName()) + | |||
549 | "' label emitted multiple times to assembly file"); | |||
550 | } | |||
551 | ||||
552 | /// emitComments - Pretty-print comments for instructions. | |||
553 | static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) { | |||
554 | const MachineFunction *MF = MI.getParent()->getParent(); | |||
555 | const TargetMachine &TM = MF->getTarget(); | |||
556 | ||||
557 | // Check for spills and reloads | |||
558 | int FI; | |||
559 | ||||
560 | const MachineFrameInfo *FrameInfo = MF->getFrameInfo(); | |||
561 | ||||
562 | // We assume a single instruction only has a spill or reload, not | |||
563 | // both. | |||
564 | const MachineMemOperand *MMO; | |||
565 | if (TM.getSubtargetImpl()->getInstrInfo()->isLoadFromStackSlotPostFE(&MI, | |||
566 | FI)) { | |||
567 | if (FrameInfo->isSpillSlotObjectIndex(FI)) { | |||
568 | MMO = *MI.memoperands_begin(); | |||
569 | CommentOS << MMO->getSize() << "-byte Reload\n"; | |||
570 | } | |||
571 | } else if (TM.getSubtargetImpl()->getInstrInfo()->hasLoadFromStackSlot( | |||
572 | &MI, MMO, FI)) { | |||
573 | if (FrameInfo->isSpillSlotObjectIndex(FI)) | |||
574 | CommentOS << MMO->getSize() << "-byte Folded Reload\n"; | |||
575 | } else if (TM.getSubtargetImpl()->getInstrInfo()->isStoreToStackSlotPostFE( | |||
576 | &MI, FI)) { | |||
577 | if (FrameInfo->isSpillSlotObjectIndex(FI)) { | |||
578 | MMO = *MI.memoperands_begin(); | |||
579 | CommentOS << MMO->getSize() << "-byte Spill\n"; | |||
580 | } | |||
581 | } else if (TM.getSubtargetImpl()->getInstrInfo()->hasStoreToStackSlot( | |||
582 | &MI, MMO, FI)) { | |||
583 | if (FrameInfo->isSpillSlotObjectIndex(FI)) | |||
584 | CommentOS << MMO->getSize() << "-byte Folded Spill\n"; | |||
585 | } | |||
586 | ||||
587 | // Check for spill-induced copies | |||
588 | if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse)) | |||
589 | CommentOS << " Reload Reuse\n"; | |||
590 | } | |||
591 | ||||
592 | /// emitImplicitDef - This method emits the specified machine instruction | |||
593 | /// that is an implicit def. | |||
594 | void AsmPrinter::emitImplicitDef(const MachineInstr *MI) const { | |||
595 | unsigned RegNo = MI->getOperand(0).getReg(); | |||
596 | OutStreamer.AddComment( | |||
597 | Twine("implicit-def: ") + | |||
598 | TM.getSubtargetImpl()->getRegisterInfo()->getName(RegNo)); | |||
599 | OutStreamer.AddBlankLine(); | |||
600 | } | |||
601 | ||||
602 | static void emitKill(const MachineInstr *MI, AsmPrinter &AP) { | |||
603 | std::string Str = "kill:"; | |||
604 | for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { | |||
605 | const MachineOperand &Op = MI->getOperand(i); | |||
606 | assert(Op.isReg() && "KILL instruction must have only register operands")((Op.isReg() && "KILL instruction must have only register operands" ) ? static_cast<void> (0) : __assert_fail ("Op.isReg() && \"KILL instruction must have only register operands\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 606, __PRETTY_FUNCTION__)); | |||
607 | Str += ' '; | |||
608 | Str += AP.TM.getSubtargetImpl()->getRegisterInfo()->getName(Op.getReg()); | |||
609 | Str += (Op.isDef() ? "<def>" : "<kill>"); | |||
610 | } | |||
611 | AP.OutStreamer.AddComment(Str); | |||
612 | AP.OutStreamer.AddBlankLine(); | |||
613 | } | |||
614 | ||||
615 | /// emitDebugValueComment - This method handles the target-independent form | |||
616 | /// of DBG_VALUE, returning true if it was able to do so. A false return | |||
617 | /// means the target will need to handle MI in EmitInstruction. | |||
618 | static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) { | |||
619 | // This code handles only the 4-operand target-independent form. | |||
620 | if (MI->getNumOperands() != 4) | |||
621 | return false; | |||
622 | ||||
623 | SmallString<128> Str; | |||
624 | raw_svector_ostream OS(Str); | |||
625 | OS << "DEBUG_VALUE: "; | |||
626 | ||||
627 | DIVariable V = MI->getDebugVariable(); | |||
628 | if (V.getContext().isSubprogram()) { | |||
629 | StringRef Name = DISubprogram(V.getContext()).getDisplayName(); | |||
630 | if (!Name.empty()) | |||
631 | OS << Name << ":"; | |||
632 | } | |||
633 | OS << V.getName(); | |||
634 | ||||
635 | DIExpression Expr = MI->getDebugExpression(); | |||
636 | if (Expr.isVariablePiece()) | |||
637 | OS << " [piece offset=" << Expr.getPieceOffset() | |||
638 | << " size=" << Expr.getPieceSize() << "]"; | |||
639 | OS << " <- "; | |||
640 | ||||
641 | // The second operand is only an offset if it's an immediate. | |||
642 | bool Deref = MI->getOperand(0).isReg() && MI->getOperand(1).isImm(); | |||
643 | int64_t Offset = Deref ? MI->getOperand(1).getImm() : 0; | |||
644 | ||||
645 | // Register or immediate value. Register 0 means undef. | |||
646 | if (MI->getOperand(0).isFPImm()) { | |||
647 | APFloat APF = APFloat(MI->getOperand(0).getFPImm()->getValueAPF()); | |||
648 | if (MI->getOperand(0).getFPImm()->getType()->isFloatTy()) { | |||
649 | OS << (double)APF.convertToFloat(); | |||
650 | } else if (MI->getOperand(0).getFPImm()->getType()->isDoubleTy()) { | |||
651 | OS << APF.convertToDouble(); | |||
652 | } else { | |||
653 | // There is no good way to print long double. Convert a copy to | |||
654 | // double. Ah well, it's only a comment. | |||
655 | bool ignored; | |||
656 | APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, | |||
657 | &ignored); | |||
658 | OS << "(long double) " << APF.convertToDouble(); | |||
659 | } | |||
660 | } else if (MI->getOperand(0).isImm()) { | |||
661 | OS << MI->getOperand(0).getImm(); | |||
662 | } else if (MI->getOperand(0).isCImm()) { | |||
663 | MI->getOperand(0).getCImm()->getValue().print(OS, false /*isSigned*/); | |||
664 | } else { | |||
665 | unsigned Reg; | |||
666 | if (MI->getOperand(0).isReg()) { | |||
667 | Reg = MI->getOperand(0).getReg(); | |||
668 | } else { | |||
669 | assert(MI->getOperand(0).isFI() && "Unknown operand type")((MI->getOperand(0).isFI() && "Unknown operand type" ) ? static_cast<void> (0) : __assert_fail ("MI->getOperand(0).isFI() && \"Unknown operand type\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 669, __PRETTY_FUNCTION__)); | |||
670 | const TargetFrameLowering *TFI = | |||
671 | AP.TM.getSubtargetImpl()->getFrameLowering(); | |||
672 | Offset += TFI->getFrameIndexReference(*AP.MF, | |||
673 | MI->getOperand(0).getIndex(), Reg); | |||
674 | Deref = true; | |||
675 | } | |||
676 | if (Reg == 0) { | |||
677 | // Suppress offset, it is not meaningful here. | |||
678 | OS << "undef"; | |||
679 | // NOTE: Want this comment at start of line, don't emit with AddComment. | |||
680 | AP.OutStreamer.emitRawComment(OS.str()); | |||
681 | return true; | |||
682 | } | |||
683 | if (Deref) | |||
684 | OS << '['; | |||
685 | OS << AP.TM.getSubtargetImpl()->getRegisterInfo()->getName(Reg); | |||
686 | } | |||
687 | ||||
688 | if (Deref) | |||
689 | OS << '+' << Offset << ']'; | |||
690 | ||||
691 | // NOTE: Want this comment at start of line, don't emit with AddComment. | |||
692 | AP.OutStreamer.emitRawComment(OS.str()); | |||
693 | return true; | |||
694 | } | |||
695 | ||||
696 | AsmPrinter::CFIMoveType AsmPrinter::needsCFIMoves() { | |||
697 | if (MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI && | |||
698 | MF->getFunction()->needsUnwindTableEntry()) | |||
699 | return CFI_M_EH; | |||
700 | ||||
701 | if (MMI->hasDebugInfo()) | |||
702 | return CFI_M_Debug; | |||
703 | ||||
704 | return CFI_M_None; | |||
705 | } | |||
706 | ||||
707 | bool AsmPrinter::needsSEHMoves() { | |||
708 | return MAI->getExceptionHandlingType() == ExceptionHandling::ItaniumWinEH && | |||
709 | MF->getFunction()->needsUnwindTableEntry(); | |||
710 | } | |||
711 | ||||
712 | void AsmPrinter::emitCFIInstruction(const MachineInstr &MI) { | |||
713 | ExceptionHandling ExceptionHandlingType = MAI->getExceptionHandlingType(); | |||
714 | if (ExceptionHandlingType != ExceptionHandling::DwarfCFI && | |||
715 | ExceptionHandlingType != ExceptionHandling::ARM) | |||
716 | return; | |||
717 | ||||
718 | if (needsCFIMoves() == CFI_M_None) | |||
719 | return; | |||
720 | ||||
721 | const MachineModuleInfo &MMI = MF->getMMI(); | |||
722 | const std::vector<MCCFIInstruction> &Instrs = MMI.getFrameInstructions(); | |||
723 | unsigned CFIIndex = MI.getOperand(0).getCFIIndex(); | |||
724 | const MCCFIInstruction &CFI = Instrs[CFIIndex]; | |||
725 | emitCFIInstruction(CFI); | |||
726 | } | |||
727 | ||||
728 | /// EmitFunctionBody - This method emits the body and trailer for a | |||
729 | /// function. | |||
730 | void AsmPrinter::EmitFunctionBody() { | |||
731 | // Emit target-specific gunk before the function body. | |||
732 | EmitFunctionBodyStart(); | |||
733 | ||||
734 | bool ShouldPrintDebugScopes = MMI->hasDebugInfo(); | |||
735 | ||||
736 | // Print out code for the function. | |||
737 | bool HasAnyRealCode = false; | |||
738 | for (auto &MBB : *MF) { | |||
739 | // Print a label for the basic block. | |||
740 | EmitBasicBlockStart(MBB); | |||
741 | for (auto &MI : MBB) { | |||
742 | ||||
743 | // Print the assembly for the instruction. | |||
744 | if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() && | |||
745 | !MI.isDebugValue()) { | |||
746 | HasAnyRealCode = true; | |||
747 | ++EmittedInsts; | |||
748 | } | |||
749 | ||||
750 | if (ShouldPrintDebugScopes) { | |||
751 | for (const HandlerInfo &HI : Handlers) { | |||
752 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, | |||
753 | TimePassesIsEnabled); | |||
754 | HI.Handler->beginInstruction(&MI); | |||
755 | } | |||
756 | } | |||
757 | ||||
758 | if (isVerbose()) | |||
759 | emitComments(MI, OutStreamer.GetCommentOS()); | |||
760 | ||||
761 | switch (MI.getOpcode()) { | |||
762 | case TargetOpcode::CFI_INSTRUCTION: | |||
763 | emitCFIInstruction(MI); | |||
764 | break; | |||
765 | ||||
766 | case TargetOpcode::EH_LABEL: | |||
767 | case TargetOpcode::GC_LABEL: | |||
768 | OutStreamer.EmitLabel(MI.getOperand(0).getMCSymbol()); | |||
769 | break; | |||
770 | case TargetOpcode::INLINEASM: | |||
771 | EmitInlineAsm(&MI); | |||
772 | break; | |||
773 | case TargetOpcode::DBG_VALUE: | |||
774 | if (isVerbose()) { | |||
775 | if (!emitDebugValueComment(&MI, *this)) | |||
776 | EmitInstruction(&MI); | |||
777 | } | |||
778 | break; | |||
779 | case TargetOpcode::IMPLICIT_DEF: | |||
780 | if (isVerbose()) emitImplicitDef(&MI); | |||
781 | break; | |||
782 | case TargetOpcode::KILL: | |||
783 | if (isVerbose()) emitKill(&MI, *this); | |||
784 | break; | |||
785 | default: | |||
786 | EmitInstruction(&MI); | |||
787 | break; | |||
788 | } | |||
789 | ||||
790 | if (ShouldPrintDebugScopes) { | |||
791 | for (const HandlerInfo &HI : Handlers) { | |||
792 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, | |||
793 | TimePassesIsEnabled); | |||
794 | HI.Handler->endInstruction(); | |||
795 | } | |||
796 | } | |||
797 | } | |||
798 | ||||
799 | EmitBasicBlockEnd(MBB); | |||
800 | } | |||
801 | ||||
802 | // If the function is empty and the object file uses .subsections_via_symbols, | |||
803 | // then we need to emit *something* to the function body to prevent the | |||
804 | // labels from collapsing together. Just emit a noop. | |||
805 | if ((MAI->hasSubsectionsViaSymbols() && !HasAnyRealCode)) { | |||
806 | MCInst Noop; | |||
807 | TM.getSubtargetImpl()->getInstrInfo()->getNoopForMachoTarget(Noop); | |||
808 | OutStreamer.AddComment("avoids zero-length function"); | |||
809 | ||||
810 | // Targets can opt-out of emitting the noop here by leaving the opcode | |||
811 | // unspecified. | |||
812 | if (Noop.getOpcode()) | |||
813 | OutStreamer.EmitInstruction(Noop, getSubtargetInfo()); | |||
814 | } | |||
815 | ||||
816 | const Function *F = MF->getFunction(); | |||
817 | for (const auto &BB : *F) { | |||
818 | if (!BB.hasAddressTaken()) | |||
819 | continue; | |||
820 | MCSymbol *Sym = GetBlockAddressSymbol(&BB); | |||
821 | if (Sym->isDefined()) | |||
822 | continue; | |||
823 | OutStreamer.AddComment("Address of block that was removed by CodeGen"); | |||
824 | OutStreamer.EmitLabel(Sym); | |||
825 | } | |||
826 | ||||
827 | // Emit target-specific gunk after the function body. | |||
828 | EmitFunctionBodyEnd(); | |||
829 | ||||
830 | // If the target wants a .size directive for the size of the function, emit | |||
831 | // it. | |||
832 | if (MAI->hasDotTypeDotSizeDirective()) { | |||
833 | // Create a symbol for the end of function, so we can get the size as | |||
834 | // difference between the function label and the temp label. | |||
835 | MCSymbol *FnEndLabel = OutContext.CreateTempSymbol(); | |||
836 | OutStreamer.EmitLabel(FnEndLabel); | |||
837 | ||||
838 | const MCExpr *SizeExp = | |||
839 | MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(FnEndLabel, OutContext), | |||
840 | MCSymbolRefExpr::Create(CurrentFnSymForSize, | |||
841 | OutContext), | |||
842 | OutContext); | |||
843 | OutStreamer.EmitELFSize(CurrentFnSym, SizeExp); | |||
844 | } | |||
845 | ||||
846 | // Emit post-function debug and/or EH information. | |||
847 | for (const HandlerInfo &HI : Handlers) { | |||
848 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, TimePassesIsEnabled); | |||
849 | HI.Handler->endFunction(MF); | |||
850 | } | |||
851 | MMI->EndFunction(); | |||
852 | ||||
853 | // Print out jump tables referenced by the function. | |||
854 | EmitJumpTableInfo(); | |||
855 | ||||
856 | OutStreamer.AddBlankLine(); | |||
857 | } | |||
858 | ||||
859 | static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP); | |||
860 | ||||
861 | bool AsmPrinter::doFinalization(Module &M) { | |||
862 | // Emit global variables. | |||
863 | for (const auto &G : M.globals()) | |||
864 | EmitGlobalVariable(&G); | |||
865 | ||||
866 | // Emit visibility info for declarations | |||
867 | for (const Function &F : M) { | |||
868 | if (!F.isDeclaration()) | |||
869 | continue; | |||
870 | GlobalValue::VisibilityTypes V = F.getVisibility(); | |||
871 | if (V == GlobalValue::DefaultVisibility) | |||
872 | continue; | |||
873 | ||||
874 | MCSymbol *Name = getSymbol(&F); | |||
875 | EmitVisibility(Name, V, false); | |||
876 | } | |||
877 | ||||
878 | // Get information about jump-instruction tables to print. | |||
879 | JumpInstrTableInfo *JITI = getAnalysisIfAvailable<JumpInstrTableInfo>(); | |||
880 | ||||
881 | if (JITI && !JITI->getTables().empty()) { | |||
882 | unsigned Arch = Triple(getTargetTriple()).getArch(); | |||
883 | bool IsThumb = (Arch == Triple::thumb || Arch == Triple::thumbeb); | |||
884 | MCInst TrapInst; | |||
885 | TM.getSubtargetImpl()->getInstrInfo()->getTrap(TrapInst); | |||
886 | unsigned LogAlignment = llvm::Log2_64(JITI->entryByteAlignment()); | |||
887 | ||||
888 | // Emit the right section for these functions. | |||
889 | OutStreamer.SwitchSection(OutContext.getObjectFileInfo()->getTextSection()); | |||
890 | for (const auto &KV : JITI->getTables()) { | |||
891 | uint64_t Count = 0; | |||
892 | for (const auto &FunPair : KV.second) { | |||
893 | // Emit the function labels to make this be a function entry point. | |||
894 | MCSymbol *FunSym = | |||
895 | OutContext.GetOrCreateSymbol(FunPair.second->getName()); | |||
896 | EmitAlignment(LogAlignment); | |||
897 | if (IsThumb) | |||
898 | OutStreamer.EmitThumbFunc(FunSym); | |||
899 | if (MAI->hasDotTypeDotSizeDirective()) | |||
900 | OutStreamer.EmitSymbolAttribute(FunSym, MCSA_ELF_TypeFunction); | |||
901 | OutStreamer.EmitLabel(FunSym); | |||
902 | ||||
903 | // Emit the jump instruction to transfer control to the original | |||
904 | // function. | |||
905 | MCInst JumpToFun; | |||
906 | MCSymbol *TargetSymbol = | |||
907 | OutContext.GetOrCreateSymbol(FunPair.first->getName()); | |||
908 | const MCSymbolRefExpr *TargetSymRef = | |||
909 | MCSymbolRefExpr::Create(TargetSymbol, MCSymbolRefExpr::VK_PLT, | |||
910 | OutContext); | |||
911 | TM.getSubtargetImpl()->getInstrInfo()->getUnconditionalBranch( | |||
912 | JumpToFun, TargetSymRef); | |||
913 | OutStreamer.EmitInstruction(JumpToFun, getSubtargetInfo()); | |||
914 | ++Count; | |||
915 | } | |||
916 | ||||
917 | // Emit enough padding instructions to fill up to the next power of two. | |||
918 | uint64_t Remaining = NextPowerOf2(Count) - Count; | |||
919 | for (uint64_t C = 0; C < Remaining; ++C) { | |||
920 | EmitAlignment(LogAlignment); | |||
921 | OutStreamer.EmitInstruction(TrapInst, getSubtargetInfo()); | |||
922 | } | |||
923 | ||||
924 | } | |||
925 | } | |||
926 | ||||
927 | // Emit module flags. | |||
928 | SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; | |||
929 | M.getModuleFlagsMetadata(ModuleFlags); | |||
930 | if (!ModuleFlags.empty()) | |||
931 | getObjFileLowering().emitModuleFlags(OutStreamer, ModuleFlags, *Mang, TM); | |||
932 | ||||
933 | // Make sure we wrote out everything we need. | |||
934 | OutStreamer.Flush(); | |||
935 | ||||
936 | // Finalize debug and EH information. | |||
937 | for (const HandlerInfo &HI : Handlers) { | |||
938 | NamedRegionTimer T(HI.TimerName, HI.TimerGroupName, | |||
939 | TimePassesIsEnabled); | |||
940 | HI.Handler->endModule(); | |||
941 | delete HI.Handler; | |||
942 | } | |||
943 | Handlers.clear(); | |||
944 | DD = nullptr; | |||
945 | ||||
946 | // If the target wants to know about weak references, print them all. | |||
947 | if (MAI->getWeakRefDirective()) { | |||
948 | // FIXME: This is not lazy, it would be nice to only print weak references | |||
949 | // to stuff that is actually used. Note that doing so would require targets | |||
950 | // to notice uses in operands (due to constant exprs etc). This should | |||
951 | // happen with the MC stuff eventually. | |||
952 | ||||
953 | // Print out module-level global variables here. | |||
954 | for (const auto &G : M.globals()) { | |||
955 | if (!G.hasExternalWeakLinkage()) | |||
956 | continue; | |||
957 | OutStreamer.EmitSymbolAttribute(getSymbol(&G), MCSA_WeakReference); | |||
958 | } | |||
959 | ||||
960 | for (const auto &F : M) { | |||
961 | if (!F.hasExternalWeakLinkage()) | |||
962 | continue; | |||
963 | OutStreamer.EmitSymbolAttribute(getSymbol(&F), MCSA_WeakReference); | |||
964 | } | |||
965 | } | |||
966 | ||||
967 | OutStreamer.AddBlankLine(); | |||
968 | for (const auto &Alias : M.aliases()) { | |||
969 | MCSymbol *Name = getSymbol(&Alias); | |||
970 | ||||
971 | if (Alias.hasExternalLinkage() || !MAI->getWeakRefDirective()) | |||
972 | OutStreamer.EmitSymbolAttribute(Name, MCSA_Global); | |||
973 | else if (Alias.hasWeakLinkage() || Alias.hasLinkOnceLinkage()) | |||
974 | OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference); | |||
975 | else | |||
976 | assert(Alias.hasLocalLinkage() && "Invalid alias linkage")((Alias.hasLocalLinkage() && "Invalid alias linkage") ? static_cast<void> (0) : __assert_fail ("Alias.hasLocalLinkage() && \"Invalid alias linkage\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 976, __PRETTY_FUNCTION__)); | |||
977 | ||||
978 | EmitVisibility(Name, Alias.getVisibility()); | |||
979 | ||||
980 | // Emit the directives as assignments aka .set: | |||
981 | OutStreamer.EmitAssignment(Name, lowerConstant(Alias.getAliasee(), *this)); | |||
982 | } | |||
983 | ||||
984 | GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); | |||
985 | assert(MI && "AsmPrinter didn't require GCModuleInfo?")((MI && "AsmPrinter didn't require GCModuleInfo?") ? static_cast <void> (0) : __assert_fail ("MI && \"AsmPrinter didn't require GCModuleInfo?\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 985, __PRETTY_FUNCTION__)); | |||
986 | for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) | |||
987 | if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(**--I)) | |||
988 | MP->finishAssembly(M, *MI, *this); | |||
989 | ||||
990 | // Emit llvm.ident metadata in an '.ident' directive. | |||
991 | EmitModuleIdents(M); | |||
992 | ||||
993 | // If we don't have any trampolines, then we don't require stack memory | |||
994 | // to be executable. Some targets have a directive to declare this. | |||
995 | Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); | |||
996 | if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) | |||
997 | if (const MCSection *S = MAI->getNonexecutableStackSection(OutContext)) | |||
998 | OutStreamer.SwitchSection(S); | |||
999 | ||||
1000 | // Allow the target to emit any magic that it wants at the end of the file, | |||
1001 | // after everything else has gone out. | |||
1002 | EmitEndOfAsmFile(M); | |||
1003 | ||||
1004 | delete Mang; Mang = nullptr; | |||
1005 | MMI = nullptr; | |||
1006 | ||||
1007 | OutStreamer.Finish(); | |||
1008 | OutStreamer.reset(); | |||
1009 | ||||
1010 | return false; | |||
1011 | } | |||
1012 | ||||
1013 | void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { | |||
1014 | this->MF = &MF; | |||
1015 | // Get the function symbol. | |||
1016 | CurrentFnSym = getSymbol(MF.getFunction()); | |||
1017 | CurrentFnSymForSize = CurrentFnSym; | |||
1018 | ||||
1019 | if (isVerbose()) | |||
1020 | LI = &getAnalysis<MachineLoopInfo>(); | |||
1021 | } | |||
1022 | ||||
1023 | namespace { | |||
1024 | // SectionCPs - Keep track the alignment, constpool entries per Section. | |||
1025 | struct SectionCPs { | |||
1026 | const MCSection *S; | |||
1027 | unsigned Alignment; | |||
1028 | SmallVector<unsigned, 4> CPEs; | |||
1029 | SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {} | |||
1030 | }; | |||
1031 | } | |||
1032 | ||||
1033 | /// EmitConstantPool - Print to the current output stream assembly | |||
1034 | /// representations of the constants in the constant pool MCP. This is | |||
1035 | /// used to print out constants which have been "spilled to memory" by | |||
1036 | /// the code generator. | |||
1037 | /// | |||
1038 | void AsmPrinter::EmitConstantPool() { | |||
1039 | const MachineConstantPool *MCP = MF->getConstantPool(); | |||
1040 | const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); | |||
1041 | if (CP.empty()) return; | |||
1042 | ||||
1043 | // Calculate sections for constant pool entries. We collect entries to go into | |||
1044 | // the same section together to reduce amount of section switch statements. | |||
1045 | SmallVector<SectionCPs, 4> CPSections; | |||
1046 | for (unsigned i = 0, e = CP.size(); i != e; ++i) { | |||
1047 | const MachineConstantPoolEntry &CPE = CP[i]; | |||
1048 | unsigned Align = CPE.getAlignment(); | |||
1049 | ||||
1050 | SectionKind Kind = | |||
1051 | CPE.getSectionKind(TM.getSubtargetImpl()->getDataLayout()); | |||
1052 | ||||
1053 | const Constant *C = nullptr; | |||
1054 | if (!CPE.isMachineConstantPoolEntry()) | |||
1055 | C = CPE.Val.ConstVal; | |||
1056 | ||||
1057 | const MCSection *S = getObjFileLowering().getSectionForConstant(Kind, C); | |||
1058 | ||||
1059 | // The number of sections are small, just do a linear search from the | |||
1060 | // last section to the first. | |||
1061 | bool Found = false; | |||
1062 | unsigned SecIdx = CPSections.size(); | |||
1063 | while (SecIdx != 0) { | |||
1064 | if (CPSections[--SecIdx].S == S) { | |||
1065 | Found = true; | |||
1066 | break; | |||
1067 | } | |||
1068 | } | |||
1069 | if (!Found) { | |||
1070 | SecIdx = CPSections.size(); | |||
1071 | CPSections.push_back(SectionCPs(S, Align)); | |||
1072 | } | |||
1073 | ||||
1074 | if (Align > CPSections[SecIdx].Alignment) | |||
1075 | CPSections[SecIdx].Alignment = Align; | |||
1076 | CPSections[SecIdx].CPEs.push_back(i); | |||
1077 | } | |||
1078 | ||||
1079 | // Now print stuff into the calculated sections. | |||
1080 | const MCSection *CurSection = nullptr; | |||
1081 | unsigned Offset = 0; | |||
1082 | for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { | |||
1083 | for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { | |||
1084 | unsigned CPI = CPSections[i].CPEs[j]; | |||
1085 | MCSymbol *Sym = GetCPISymbol(CPI); | |||
1086 | if (!Sym->isUndefined()) | |||
1087 | continue; | |||
1088 | ||||
1089 | if (CurSection != CPSections[i].S) { | |||
1090 | OutStreamer.SwitchSection(CPSections[i].S); | |||
1091 | EmitAlignment(Log2_32(CPSections[i].Alignment)); | |||
1092 | CurSection = CPSections[i].S; | |||
1093 | Offset = 0; | |||
1094 | } | |||
1095 | ||||
1096 | MachineConstantPoolEntry CPE = CP[CPI]; | |||
1097 | ||||
1098 | // Emit inter-object padding for alignment. | |||
1099 | unsigned AlignMask = CPE.getAlignment() - 1; | |||
1100 | unsigned NewOffset = (Offset + AlignMask) & ~AlignMask; | |||
1101 | OutStreamer.EmitZeros(NewOffset - Offset); | |||
1102 | ||||
1103 | Type *Ty = CPE.getType(); | |||
1104 | Offset = NewOffset + | |||
1105 | TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize(Ty); | |||
1106 | ||||
1107 | OutStreamer.EmitLabel(Sym); | |||
1108 | if (CPE.isMachineConstantPoolEntry()) | |||
1109 | EmitMachineConstantPoolValue(CPE.Val.MachineCPVal); | |||
1110 | else | |||
1111 | EmitGlobalConstant(CPE.Val.ConstVal); | |||
1112 | } | |||
1113 | } | |||
1114 | } | |||
1115 | ||||
1116 | /// EmitJumpTableInfo - Print assembly representations of the jump tables used | |||
1117 | /// by the current function to the current output stream. | |||
1118 | /// | |||
1119 | void AsmPrinter::EmitJumpTableInfo() { | |||
1120 | const DataLayout *DL = MF->getSubtarget().getDataLayout(); | |||
1121 | const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); | |||
1122 | if (!MJTI) return; | |||
1123 | if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return; | |||
1124 | const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); | |||
1125 | if (JT.empty()) return; | |||
1126 | ||||
1127 | // Pick the directive to use to print the jump table entries, and switch to | |||
1128 | // the appropriate section. | |||
1129 | const Function *F = MF->getFunction(); | |||
1130 | bool JTInDiffSection = false; | |||
1131 | if (// In PIC mode, we need to emit the jump table to the same section as the | |||
1132 | // function body itself, otherwise the label differences won't make sense. | |||
1133 | // FIXME: Need a better predicate for this: what about custom entries? | |||
1134 | MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 || | |||
1135 | // We should also do if the section name is NULL or function is declared | |||
1136 | // in discardable section | |||
1137 | // FIXME: this isn't the right predicate, should be based on the MCSection | |||
1138 | // for the function. | |||
1139 | F->isWeakForLinker()) { | |||
1140 | OutStreamer.SwitchSection( | |||
1141 | getObjFileLowering().SectionForGlobal(F, *Mang, TM)); | |||
1142 | } else { | |||
1143 | // Otherwise, drop it in the readonly section. | |||
1144 | const MCSection *ReadOnlySection = | |||
1145 | getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly(), | |||
1146 | /*C=*/nullptr); | |||
1147 | OutStreamer.SwitchSection(ReadOnlySection); | |||
1148 | JTInDiffSection = true; | |||
1149 | } | |||
1150 | ||||
1151 | EmitAlignment(Log2_32( | |||
1152 | MJTI->getEntryAlignment(*TM.getSubtargetImpl()->getDataLayout()))); | |||
1153 | ||||
1154 | // Jump tables in code sections are marked with a data_region directive | |||
1155 | // where that's supported. | |||
1156 | if (!JTInDiffSection) | |||
1157 | OutStreamer.EmitDataRegion(MCDR_DataRegionJT32); | |||
1158 | ||||
1159 | for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) { | |||
1160 | const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; | |||
1161 | ||||
1162 | // If this jump table was deleted, ignore it. | |||
1163 | if (JTBBs.empty()) continue; | |||
1164 | ||||
1165 | // For the EK_LabelDifference32 entry, if using .set avoids a relocation, | |||
1166 | /// emit a .set directive for each unique entry. | |||
1167 | if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 && | |||
1168 | MAI->doesSetDirectiveSuppressesReloc()) { | |||
1169 | SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets; | |||
1170 | const TargetLowering *TLI = TM.getSubtargetImpl()->getTargetLowering(); | |||
1171 | const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF,JTI,OutContext); | |||
1172 | for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { | |||
1173 | const MachineBasicBlock *MBB = JTBBs[ii]; | |||
1174 | if (!EmittedSets.insert(MBB).second) | |||
1175 | continue; | |||
1176 | ||||
1177 | // .set LJTSet, LBB32-base | |||
1178 | const MCExpr *LHS = | |||
1179 | MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); | |||
1180 | OutStreamer.EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()), | |||
1181 | MCBinaryExpr::CreateSub(LHS, Base, OutContext)); | |||
1182 | } | |||
1183 | } | |||
1184 | ||||
1185 | // On some targets (e.g. Darwin) we want to emit two consecutive labels | |||
1186 | // before each jump table. The first label is never referenced, but tells | |||
1187 | // the assembler and linker the extents of the jump table object. The | |||
1188 | // second label is actually referenced by the code. | |||
1189 | if (JTInDiffSection && DL->hasLinkerPrivateGlobalPrefix()) | |||
1190 | // FIXME: This doesn't have to have any specific name, just any randomly | |||
1191 | // named and numbered 'l' label would work. Simplify GetJTISymbol. | |||
1192 | OutStreamer.EmitLabel(GetJTISymbol(JTI, true)); | |||
1193 | ||||
1194 | OutStreamer.EmitLabel(GetJTISymbol(JTI)); | |||
1195 | ||||
1196 | for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) | |||
1197 | EmitJumpTableEntry(MJTI, JTBBs[ii], JTI); | |||
1198 | } | |||
1199 | if (!JTInDiffSection) | |||
1200 | OutStreamer.EmitDataRegion(MCDR_DataRegionEnd); | |||
1201 | } | |||
1202 | ||||
1203 | /// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the | |||
1204 | /// current stream. | |||
1205 | void AsmPrinter::EmitJumpTableEntry(const MachineJumpTableInfo *MJTI, | |||
1206 | const MachineBasicBlock *MBB, | |||
1207 | unsigned UID) const { | |||
1208 | assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block")((MBB && MBB->getNumber() >= 0 && "Invalid basic block" ) ? static_cast<void> (0) : __assert_fail ("MBB && MBB->getNumber() >= 0 && \"Invalid basic block\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1208, __PRETTY_FUNCTION__)); | |||
1209 | const MCExpr *Value = nullptr; | |||
1210 | switch (MJTI->getEntryKind()) { | |||
1211 | case MachineJumpTableInfo::EK_Inline: | |||
1212 | llvm_unreachable("Cannot emit EK_Inline jump table entry")::llvm::llvm_unreachable_internal("Cannot emit EK_Inline jump table entry" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1212); | |||
1213 | case MachineJumpTableInfo::EK_Custom32: | |||
1214 | Value = | |||
1215 | TM.getSubtargetImpl()->getTargetLowering()->LowerCustomJumpTableEntry( | |||
1216 | MJTI, MBB, UID, OutContext); | |||
1217 | break; | |||
1218 | case MachineJumpTableInfo::EK_BlockAddress: | |||
1219 | // EK_BlockAddress - Each entry is a plain address of block, e.g.: | |||
1220 | // .word LBB123 | |||
1221 | Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); | |||
1222 | break; | |||
1223 | case MachineJumpTableInfo::EK_GPRel32BlockAddress: { | |||
1224 | // EK_GPRel32BlockAddress - Each entry is an address of block, encoded | |||
1225 | // with a relocation as gp-relative, e.g.: | |||
1226 | // .gprel32 LBB123 | |||
1227 | MCSymbol *MBBSym = MBB->getSymbol(); | |||
1228 | OutStreamer.EmitGPRel32Value(MCSymbolRefExpr::Create(MBBSym, OutContext)); | |||
1229 | return; | |||
1230 | } | |||
1231 | ||||
1232 | case MachineJumpTableInfo::EK_GPRel64BlockAddress: { | |||
1233 | // EK_GPRel64BlockAddress - Each entry is an address of block, encoded | |||
1234 | // with a relocation as gp-relative, e.g.: | |||
1235 | // .gpdword LBB123 | |||
1236 | MCSymbol *MBBSym = MBB->getSymbol(); | |||
1237 | OutStreamer.EmitGPRel64Value(MCSymbolRefExpr::Create(MBBSym, OutContext)); | |||
1238 | return; | |||
1239 | } | |||
1240 | ||||
1241 | case MachineJumpTableInfo::EK_LabelDifference32: { | |||
1242 | // Each entry is the address of the block minus the address of the jump | |||
1243 | // table. This is used for PIC jump tables where gprel32 is not supported. | |||
1244 | // e.g.: | |||
1245 | // .word LBB123 - LJTI1_2 | |||
1246 | // If the .set directive avoids relocations, this is emitted as: | |||
1247 | // .set L4_5_set_123, LBB123 - LJTI1_2 | |||
1248 | // .word L4_5_set_123 | |||
1249 | if (MAI->doesSetDirectiveSuppressesReloc()) { | |||
1250 | Value = MCSymbolRefExpr::Create(GetJTSetSymbol(UID, MBB->getNumber()), | |||
1251 | OutContext); | |||
1252 | break; | |||
1253 | } | |||
1254 | Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); | |||
1255 | const TargetLowering *TLI = TM.getSubtargetImpl()->getTargetLowering(); | |||
1256 | const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF, UID, OutContext); | |||
1257 | Value = MCBinaryExpr::CreateSub(Value, Base, OutContext); | |||
1258 | break; | |||
1259 | } | |||
1260 | } | |||
1261 | ||||
1262 | assert(Value && "Unknown entry kind!")((Value && "Unknown entry kind!") ? static_cast<void > (0) : __assert_fail ("Value && \"Unknown entry kind!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1262, __PRETTY_FUNCTION__)); | |||
1263 | ||||
1264 | unsigned EntrySize = | |||
1265 | MJTI->getEntrySize(*TM.getSubtargetImpl()->getDataLayout()); | |||
1266 | OutStreamer.EmitValue(Value, EntrySize); | |||
1267 | } | |||
1268 | ||||
1269 | ||||
1270 | /// EmitSpecialLLVMGlobal - Check to see if the specified global is a | |||
1271 | /// special global used by LLVM. If so, emit it and return true, otherwise | |||
1272 | /// do nothing and return false. | |||
1273 | bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { | |||
1274 | if (GV->getName() == "llvm.used") { | |||
1275 | if (MAI->hasNoDeadStrip()) // No need to emit this at all. | |||
1276 | EmitLLVMUsedList(cast<ConstantArray>(GV->getInitializer())); | |||
1277 | return true; | |||
1278 | } | |||
1279 | ||||
1280 | // Ignore debug and non-emitted data. This handles llvm.compiler.used. | |||
1281 | if (StringRef(GV->getSection()) == "llvm.metadata" || | |||
1282 | GV->hasAvailableExternallyLinkage()) | |||
1283 | return true; | |||
1284 | ||||
1285 | if (!GV->hasAppendingLinkage()) return false; | |||
1286 | ||||
1287 | assert(GV->hasInitializer() && "Not a special LLVM global!")((GV->hasInitializer() && "Not a special LLVM global!" ) ? static_cast<void> (0) : __assert_fail ("GV->hasInitializer() && \"Not a special LLVM global!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1287, __PRETTY_FUNCTION__)); | |||
1288 | ||||
1289 | if (GV->getName() == "llvm.global_ctors") { | |||
1290 | EmitXXStructorList(GV->getInitializer(), /* isCtor */ true); | |||
1291 | ||||
1292 | if (TM.getRelocationModel() == Reloc::Static && | |||
1293 | MAI->hasStaticCtorDtorReferenceInStaticMode()) { | |||
1294 | StringRef Sym(".constructors_used"); | |||
1295 | OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), | |||
1296 | MCSA_Reference); | |||
1297 | } | |||
1298 | return true; | |||
1299 | } | |||
1300 | ||||
1301 | if (GV->getName() == "llvm.global_dtors") { | |||
1302 | EmitXXStructorList(GV->getInitializer(), /* isCtor */ false); | |||
1303 | ||||
1304 | if (TM.getRelocationModel() == Reloc::Static && | |||
1305 | MAI->hasStaticCtorDtorReferenceInStaticMode()) { | |||
1306 | StringRef Sym(".destructors_used"); | |||
1307 | OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), | |||
1308 | MCSA_Reference); | |||
1309 | } | |||
1310 | return true; | |||
1311 | } | |||
1312 | ||||
1313 | return false; | |||
1314 | } | |||
1315 | ||||
1316 | /// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each | |||
1317 | /// global in the specified llvm.used list for which emitUsedDirectiveFor | |||
1318 | /// is true, as being used with this directive. | |||
1319 | void AsmPrinter::EmitLLVMUsedList(const ConstantArray *InitList) { | |||
1320 | // Should be an array of 'i8*'. | |||
1321 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { | |||
1322 | const GlobalValue *GV = | |||
1323 | dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); | |||
1324 | if (GV) | |||
1325 | OutStreamer.EmitSymbolAttribute(getSymbol(GV), MCSA_NoDeadStrip); | |||
1326 | } | |||
1327 | } | |||
1328 | ||||
1329 | namespace { | |||
1330 | struct Structor { | |||
1331 | Structor() : Priority(0), Func(nullptr), ComdatKey(nullptr) {} | |||
1332 | int Priority; | |||
1333 | llvm::Constant *Func; | |||
1334 | llvm::GlobalValue *ComdatKey; | |||
1335 | }; | |||
1336 | } // end namespace | |||
1337 | ||||
1338 | /// EmitXXStructorList - Emit the ctor or dtor list taking into account the init | |||
1339 | /// priority. | |||
1340 | void AsmPrinter::EmitXXStructorList(const Constant *List, bool isCtor) { | |||
1341 | // Should be an array of '{ int, void ()* }' structs. The first value is the | |||
1342 | // init priority. | |||
1343 | if (!isa<ConstantArray>(List)) return; | |||
1344 | ||||
1345 | // Sanity check the structors list. | |||
1346 | const ConstantArray *InitList = dyn_cast<ConstantArray>(List); | |||
1347 | if (!InitList) return; // Not an array! | |||
1348 | StructType *ETy = dyn_cast<StructType>(InitList->getType()->getElementType()); | |||
1349 | // FIXME: Only allow the 3-field form in LLVM 4.0. | |||
1350 | if (!ETy || ETy->getNumElements() < 2 || ETy->getNumElements() > 3) | |||
1351 | return; // Not an array of two or three elements! | |||
1352 | if (!isa<IntegerType>(ETy->getTypeAtIndex(0U)) || | |||
1353 | !isa<PointerType>(ETy->getTypeAtIndex(1U))) return; // Not (int, ptr). | |||
1354 | if (ETy->getNumElements() == 3 && !isa<PointerType>(ETy->getTypeAtIndex(2U))) | |||
1355 | return; // Not (int, ptr, ptr). | |||
1356 | ||||
1357 | // Gather the structors in a form that's convenient for sorting by priority. | |||
1358 | SmallVector<Structor, 8> Structors; | |||
1359 | for (Value *O : InitList->operands()) { | |||
1360 | ConstantStruct *CS = dyn_cast<ConstantStruct>(O); | |||
1361 | if (!CS) continue; // Malformed. | |||
1362 | if (CS->getOperand(1)->isNullValue()) | |||
1363 | break; // Found a null terminator, skip the rest. | |||
1364 | ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0)); | |||
1365 | if (!Priority) continue; // Malformed. | |||
1366 | Structors.push_back(Structor()); | |||
1367 | Structor &S = Structors.back(); | |||
1368 | S.Priority = Priority->getLimitedValue(65535); | |||
1369 | S.Func = CS->getOperand(1); | |||
1370 | if (ETy->getNumElements() == 3 && !CS->getOperand(2)->isNullValue()) | |||
1371 | S.ComdatKey = dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts()); | |||
1372 | } | |||
1373 | ||||
1374 | // Emit the function pointers in the target-specific order | |||
1375 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
1376 | unsigned Align = Log2_32(DL->getPointerPrefAlignment()); | |||
1377 | std::stable_sort(Structors.begin(), Structors.end(), | |||
1378 | [](const Structor &L, | |||
1379 | const Structor &R) { return L.Priority < R.Priority; }); | |||
1380 | for (Structor &S : Structors) { | |||
1381 | const TargetLoweringObjectFile &Obj = getObjFileLowering(); | |||
1382 | const MCSymbol *KeySym = nullptr; | |||
1383 | if (GlobalValue *GV = S.ComdatKey) { | |||
1384 | if (GV->hasAvailableExternallyLinkage()) | |||
1385 | // If the associated variable is available_externally, some other TU | |||
1386 | // will provide its dynamic initializer. | |||
1387 | continue; | |||
1388 | ||||
1389 | KeySym = getSymbol(GV); | |||
1390 | } | |||
1391 | const MCSection *OutputSection = | |||
1392 | (isCtor ? Obj.getStaticCtorSection(S.Priority, KeySym) | |||
1393 | : Obj.getStaticDtorSection(S.Priority, KeySym)); | |||
1394 | OutStreamer.SwitchSection(OutputSection); | |||
1395 | if (OutStreamer.getCurrentSection() != OutStreamer.getPreviousSection()) | |||
1396 | EmitAlignment(Align); | |||
1397 | EmitXXStructor(S.Func); | |||
1398 | } | |||
1399 | } | |||
1400 | ||||
1401 | void AsmPrinter::EmitModuleIdents(Module &M) { | |||
1402 | if (!MAI->hasIdentDirective()) | |||
1403 | return; | |||
1404 | ||||
1405 | if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) { | |||
1406 | for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { | |||
1407 | const MDNode *N = NMD->getOperand(i); | |||
1408 | assert(N->getNumOperands() == 1 &&((N->getNumOperands() == 1 && "llvm.ident metadata entry can have only one operand" ) ? static_cast<void> (0) : __assert_fail ("N->getNumOperands() == 1 && \"llvm.ident metadata entry can have only one operand\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1409, __PRETTY_FUNCTION__)) | |||
1409 | "llvm.ident metadata entry can have only one operand")((N->getNumOperands() == 1 && "llvm.ident metadata entry can have only one operand" ) ? static_cast<void> (0) : __assert_fail ("N->getNumOperands() == 1 && \"llvm.ident metadata entry can have only one operand\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1409, __PRETTY_FUNCTION__)); | |||
1410 | const MDString *S = cast<MDString>(N->getOperand(0)); | |||
1411 | OutStreamer.EmitIdent(S->getString()); | |||
1412 | } | |||
1413 | } | |||
1414 | } | |||
1415 | ||||
1416 | //===--------------------------------------------------------------------===// | |||
1417 | // Emission and print routines | |||
1418 | // | |||
1419 | ||||
1420 | /// EmitInt8 - Emit a byte directive and value. | |||
1421 | /// | |||
1422 | void AsmPrinter::EmitInt8(int Value) const { | |||
1423 | OutStreamer.EmitIntValue(Value, 1); | |||
1424 | } | |||
1425 | ||||
1426 | /// EmitInt16 - Emit a short directive and value. | |||
1427 | /// | |||
1428 | void AsmPrinter::EmitInt16(int Value) const { | |||
1429 | OutStreamer.EmitIntValue(Value, 2); | |||
1430 | } | |||
1431 | ||||
1432 | /// EmitInt32 - Emit a long directive and value. | |||
1433 | /// | |||
1434 | void AsmPrinter::EmitInt32(int Value) const { | |||
1435 | OutStreamer.EmitIntValue(Value, 4); | |||
1436 | } | |||
1437 | ||||
1438 | /// Emit something like ".long Hi-Lo" where the size in bytes of the directive | |||
1439 | /// is specified by Size and Hi/Lo specify the labels. This implicitly uses | |||
1440 | /// .set if it avoids relocations. | |||
1441 | void AsmPrinter::EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, | |||
1442 | unsigned Size) const { | |||
1443 | // Get the Hi-Lo expression. | |||
1444 | const MCExpr *Diff = | |||
1445 | MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(Hi, OutContext), | |||
1446 | MCSymbolRefExpr::Create(Lo, OutContext), | |||
1447 | OutContext); | |||
1448 | ||||
1449 | if (!MAI->doesSetDirectiveSuppressesReloc()) { | |||
1450 | OutStreamer.EmitValue(Diff, Size); | |||
1451 | return; | |||
1452 | } | |||
1453 | ||||
1454 | // Otherwise, emit with .set (aka assignment). | |||
1455 | MCSymbol *SetLabel = GetTempSymbol("set", SetCounter++); | |||
1456 | OutStreamer.EmitAssignment(SetLabel, Diff); | |||
1457 | OutStreamer.EmitSymbolValue(SetLabel, Size); | |||
1458 | } | |||
1459 | ||||
1460 | /// EmitLabelPlusOffset - Emit something like ".long Label+Offset" | |||
1461 | /// where the size in bytes of the directive is specified by Size and Label | |||
1462 | /// specifies the label. This implicitly uses .set if it is available. | |||
1463 | void AsmPrinter::EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, | |||
1464 | unsigned Size, | |||
1465 | bool IsSectionRelative) const { | |||
1466 | if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) { | |||
1467 | OutStreamer.EmitCOFFSecRel32(Label); | |||
1468 | return; | |||
1469 | } | |||
1470 | ||||
1471 | // Emit Label+Offset (or just Label if Offset is zero) | |||
1472 | const MCExpr *Expr = MCSymbolRefExpr::Create(Label, OutContext); | |||
1473 | if (Offset) | |||
1474 | Expr = MCBinaryExpr::CreateAdd( | |||
1475 | Expr, MCConstantExpr::Create(Offset, OutContext), OutContext); | |||
1476 | ||||
1477 | OutStreamer.EmitValue(Expr, Size); | |||
1478 | } | |||
1479 | ||||
1480 | //===----------------------------------------------------------------------===// | |||
1481 | ||||
1482 | // EmitAlignment - Emit an alignment directive to the specified power of | |||
1483 | // two boundary. For example, if you pass in 3 here, you will get an 8 | |||
1484 | // byte alignment. If a global value is specified, and if that global has | |||
1485 | // an explicit alignment requested, it will override the alignment request | |||
1486 | // if required for correctness. | |||
1487 | // | |||
1488 | void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalObject *GV) const { | |||
1489 | if (GV) | |||
1490 | NumBits = getGVAlignmentLog2(GV, *TM.getSubtargetImpl()->getDataLayout(), | |||
1491 | NumBits); | |||
1492 | ||||
1493 | if (NumBits == 0) return; // 1-byte aligned: no need to emit alignment. | |||
1494 | ||||
1495 | if (getCurrentSection()->getKind().isText()) | |||
1496 | OutStreamer.EmitCodeAlignment(1 << NumBits); | |||
| ||||
1497 | else | |||
1498 | OutStreamer.EmitValueToAlignment(1 << NumBits); | |||
1499 | } | |||
1500 | ||||
1501 | //===----------------------------------------------------------------------===// | |||
1502 | // Constant emission. | |||
1503 | //===----------------------------------------------------------------------===// | |||
1504 | ||||
1505 | /// lowerConstant - Lower the specified LLVM Constant to an MCExpr. | |||
1506 | /// | |||
1507 | static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) { | |||
1508 | MCContext &Ctx = AP.OutContext; | |||
1509 | ||||
1510 | if (CV->isNullValue() || isa<UndefValue>(CV)) | |||
1511 | return MCConstantExpr::Create(0, Ctx); | |||
1512 | ||||
1513 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) | |||
1514 | return MCConstantExpr::Create(CI->getZExtValue(), Ctx); | |||
1515 | ||||
1516 | if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) | |||
1517 | return MCSymbolRefExpr::Create(AP.getSymbol(GV), Ctx); | |||
1518 | ||||
1519 | if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) | |||
1520 | return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx); | |||
1521 | ||||
1522 | const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); | |||
1523 | if (!CE) { | |||
1524 | llvm_unreachable("Unknown constant value to lower!")::llvm::llvm_unreachable_internal("Unknown constant value to lower!" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1524); | |||
1525 | } | |||
1526 | ||||
1527 | if (const MCExpr *RelocExpr = | |||
1528 | AP.getObjFileLowering().getExecutableRelativeSymbol(CE, *AP.Mang, | |||
1529 | AP.TM)) | |||
1530 | return RelocExpr; | |||
1531 | ||||
1532 | switch (CE->getOpcode()) { | |||
1533 | default: | |||
1534 | // If the code isn't optimized, there may be outstanding folding | |||
1535 | // opportunities. Attempt to fold the expression using DataLayout as a | |||
1536 | // last resort before giving up. | |||
1537 | if (Constant *C = ConstantFoldConstantExpression( | |||
1538 | CE, AP.TM.getSubtargetImpl()->getDataLayout())) | |||
1539 | if (C != CE) | |||
1540 | return lowerConstant(C, AP); | |||
1541 | ||||
1542 | // Otherwise report the problem to the user. | |||
1543 | { | |||
1544 | std::string S; | |||
1545 | raw_string_ostream OS(S); | |||
1546 | OS << "Unsupported expression in static initializer: "; | |||
1547 | CE->printAsOperand(OS, /*PrintType=*/false, | |||
1548 | !AP.MF ? nullptr : AP.MF->getFunction()->getParent()); | |||
1549 | report_fatal_error(OS.str()); | |||
1550 | } | |||
1551 | case Instruction::GetElementPtr: { | |||
1552 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1553 | // Generate a symbolic expression for the byte address | |||
1554 | APInt OffsetAI(DL.getPointerTypeSizeInBits(CE->getType()), 0); | |||
1555 | cast<GEPOperator>(CE)->accumulateConstantOffset(DL, OffsetAI); | |||
1556 | ||||
1557 | const MCExpr *Base = lowerConstant(CE->getOperand(0), AP); | |||
1558 | if (!OffsetAI) | |||
1559 | return Base; | |||
1560 | ||||
1561 | int64_t Offset = OffsetAI.getSExtValue(); | |||
1562 | return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx), | |||
1563 | Ctx); | |||
1564 | } | |||
1565 | ||||
1566 | case Instruction::Trunc: | |||
1567 | // We emit the value and depend on the assembler to truncate the generated | |||
1568 | // expression properly. This is important for differences between | |||
1569 | // blockaddress labels. Since the two labels are in the same function, it | |||
1570 | // is reasonable to treat their delta as a 32-bit value. | |||
1571 | // FALL THROUGH. | |||
1572 | case Instruction::BitCast: | |||
1573 | return lowerConstant(CE->getOperand(0), AP); | |||
1574 | ||||
1575 | case Instruction::IntToPtr: { | |||
1576 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1577 | // Handle casts to pointers by changing them into casts to the appropriate | |||
1578 | // integer type. This promotes constant folding and simplifies this code. | |||
1579 | Constant *Op = CE->getOperand(0); | |||
1580 | Op = ConstantExpr::getIntegerCast(Op, DL.getIntPtrType(CV->getType()), | |||
1581 | false/*ZExt*/); | |||
1582 | return lowerConstant(Op, AP); | |||
1583 | } | |||
1584 | ||||
1585 | case Instruction::PtrToInt: { | |||
1586 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1587 | // Support only foldable casts to/from pointers that can be eliminated by | |||
1588 | // changing the pointer to the appropriately sized integer type. | |||
1589 | Constant *Op = CE->getOperand(0); | |||
1590 | Type *Ty = CE->getType(); | |||
1591 | ||||
1592 | const MCExpr *OpExpr = lowerConstant(Op, AP); | |||
1593 | ||||
1594 | // We can emit the pointer value into this slot if the slot is an | |||
1595 | // integer slot equal to the size of the pointer. | |||
1596 | if (DL.getTypeAllocSize(Ty) == DL.getTypeAllocSize(Op->getType())) | |||
1597 | return OpExpr; | |||
1598 | ||||
1599 | // Otherwise the pointer is smaller than the resultant integer, mask off | |||
1600 | // the high bits so we are sure to get a proper truncation if the input is | |||
1601 | // a constant expr. | |||
1602 | unsigned InBits = DL.getTypeAllocSizeInBits(Op->getType()); | |||
1603 | const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx); | |||
1604 | return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx); | |||
1605 | } | |||
1606 | ||||
1607 | // The MC library also has a right-shift operator, but it isn't consistently | |||
1608 | // signed or unsigned between different targets. | |||
1609 | case Instruction::Add: | |||
1610 | case Instruction::Sub: | |||
1611 | case Instruction::Mul: | |||
1612 | case Instruction::SDiv: | |||
1613 | case Instruction::SRem: | |||
1614 | case Instruction::Shl: | |||
1615 | case Instruction::And: | |||
1616 | case Instruction::Or: | |||
1617 | case Instruction::Xor: { | |||
1618 | const MCExpr *LHS = lowerConstant(CE->getOperand(0), AP); | |||
1619 | const MCExpr *RHS = lowerConstant(CE->getOperand(1), AP); | |||
1620 | switch (CE->getOpcode()) { | |||
1621 | default: llvm_unreachable("Unknown binary operator constant cast expr")::llvm::llvm_unreachable_internal("Unknown binary operator constant cast expr" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1621); | |||
1622 | case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx); | |||
1623 | case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx); | |||
1624 | case Instruction::Mul: return MCBinaryExpr::CreateMul(LHS, RHS, Ctx); | |||
1625 | case Instruction::SDiv: return MCBinaryExpr::CreateDiv(LHS, RHS, Ctx); | |||
1626 | case Instruction::SRem: return MCBinaryExpr::CreateMod(LHS, RHS, Ctx); | |||
1627 | case Instruction::Shl: return MCBinaryExpr::CreateShl(LHS, RHS, Ctx); | |||
1628 | case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx); | |||
1629 | case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx); | |||
1630 | case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx); | |||
1631 | } | |||
1632 | } | |||
1633 | } | |||
1634 | } | |||
1635 | ||||
1636 | static void emitGlobalConstantImpl(const Constant *C, AsmPrinter &AP); | |||
1637 | ||||
1638 | /// isRepeatedByteSequence - Determine whether the given value is | |||
1639 | /// composed of a repeated sequence of identical bytes and return the | |||
1640 | /// byte value. If it is not a repeated sequence, return -1. | |||
1641 | static int isRepeatedByteSequence(const ConstantDataSequential *V) { | |||
1642 | StringRef Data = V->getRawDataValues(); | |||
1643 | assert(!Data.empty() && "Empty aggregates should be CAZ node")((!Data.empty() && "Empty aggregates should be CAZ node" ) ? static_cast<void> (0) : __assert_fail ("!Data.empty() && \"Empty aggregates should be CAZ node\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1643, __PRETTY_FUNCTION__)); | |||
1644 | char C = Data[0]; | |||
1645 | for (unsigned i = 1, e = Data.size(); i != e; ++i) | |||
1646 | if (Data[i] != C) return -1; | |||
1647 | return static_cast<uint8_t>(C); // Ensure 255 is not returned as -1. | |||
1648 | } | |||
1649 | ||||
1650 | ||||
1651 | /// isRepeatedByteSequence - Determine whether the given value is | |||
1652 | /// composed of a repeated sequence of identical bytes and return the | |||
1653 | /// byte value. If it is not a repeated sequence, return -1. | |||
1654 | static int isRepeatedByteSequence(const Value *V, TargetMachine &TM) { | |||
1655 | ||||
1656 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { | |||
1657 | if (CI->getBitWidth() > 64) return -1; | |||
1658 | ||||
1659 | uint64_t Size = | |||
1660 | TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize(V->getType()); | |||
1661 | uint64_t Value = CI->getZExtValue(); | |||
1662 | ||||
1663 | // Make sure the constant is at least 8 bits long and has a power | |||
1664 | // of 2 bit width. This guarantees the constant bit width is | |||
1665 | // always a multiple of 8 bits, avoiding issues with padding out | |||
1666 | // to Size and other such corner cases. | |||
1667 | if (CI->getBitWidth() < 8 || !isPowerOf2_64(CI->getBitWidth())) return -1; | |||
1668 | ||||
1669 | uint8_t Byte = static_cast<uint8_t>(Value); | |||
1670 | ||||
1671 | for (unsigned i = 1; i < Size; ++i) { | |||
1672 | Value >>= 8; | |||
1673 | if (static_cast<uint8_t>(Value) != Byte) return -1; | |||
1674 | } | |||
1675 | return Byte; | |||
1676 | } | |||
1677 | if (const ConstantArray *CA = dyn_cast<ConstantArray>(V)) { | |||
1678 | // Make sure all array elements are sequences of the same repeated | |||
1679 | // byte. | |||
1680 | assert(CA->getNumOperands() != 0 && "Should be a CAZ")((CA->getNumOperands() != 0 && "Should be a CAZ") ? static_cast<void> (0) : __assert_fail ("CA->getNumOperands() != 0 && \"Should be a CAZ\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1680, __PRETTY_FUNCTION__)); | |||
1681 | int Byte = isRepeatedByteSequence(CA->getOperand(0), TM); | |||
1682 | if (Byte == -1) return -1; | |||
1683 | ||||
1684 | for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) { | |||
1685 | int ThisByte = isRepeatedByteSequence(CA->getOperand(i), TM); | |||
1686 | if (ThisByte == -1) return -1; | |||
1687 | if (Byte != ThisByte) return -1; | |||
1688 | } | |||
1689 | return Byte; | |||
1690 | } | |||
1691 | ||||
1692 | if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V)) | |||
1693 | return isRepeatedByteSequence(CDS); | |||
1694 | ||||
1695 | return -1; | |||
1696 | } | |||
1697 | ||||
1698 | static void emitGlobalConstantDataSequential(const ConstantDataSequential *CDS, | |||
1699 | AsmPrinter &AP){ | |||
1700 | ||||
1701 | // See if we can aggregate this into a .fill, if so, emit it as such. | |||
1702 | int Value = isRepeatedByteSequence(CDS, AP.TM); | |||
1703 | if (Value != -1) { | |||
1704 | uint64_t Bytes = | |||
1705 | AP.TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize( | |||
1706 | CDS->getType()); | |||
1707 | // Don't emit a 1-byte object as a .fill. | |||
1708 | if (Bytes > 1) | |||
1709 | return AP.OutStreamer.EmitFill(Bytes, Value); | |||
1710 | } | |||
1711 | ||||
1712 | // If this can be emitted with .ascii/.asciz, emit it as such. | |||
1713 | if (CDS->isString()) | |||
1714 | return AP.OutStreamer.EmitBytes(CDS->getAsString()); | |||
1715 | ||||
1716 | // Otherwise, emit the values in successive locations. | |||
1717 | unsigned ElementByteSize = CDS->getElementByteSize(); | |||
1718 | if (isa<IntegerType>(CDS->getElementType())) { | |||
1719 | for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) { | |||
1720 | if (AP.isVerbose()) | |||
1721 | AP.OutStreamer.GetCommentOS() << format("0x%" PRIx64"l" "x" "\n", | |||
1722 | CDS->getElementAsInteger(i)); | |||
1723 | AP.OutStreamer.EmitIntValue(CDS->getElementAsInteger(i), | |||
1724 | ElementByteSize); | |||
1725 | } | |||
1726 | } else if (ElementByteSize == 4) { | |||
1727 | // FP Constants are printed as integer constants to avoid losing | |||
1728 | // precision. | |||
1729 | assert(CDS->getElementType()->isFloatTy())((CDS->getElementType()->isFloatTy()) ? static_cast< void> (0) : __assert_fail ("CDS->getElementType()->isFloatTy()" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1729, __PRETTY_FUNCTION__)); | |||
1730 | for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) { | |||
1731 | union { | |||
1732 | float F; | |||
1733 | uint32_t I; | |||
1734 | }; | |||
1735 | ||||
1736 | F = CDS->getElementAsFloat(i); | |||
1737 | if (AP.isVerbose()) | |||
1738 | AP.OutStreamer.GetCommentOS() << "float " << F << '\n'; | |||
1739 | AP.OutStreamer.EmitIntValue(I, 4); | |||
1740 | } | |||
1741 | } else { | |||
1742 | assert(CDS->getElementType()->isDoubleTy())((CDS->getElementType()->isDoubleTy()) ? static_cast< void> (0) : __assert_fail ("CDS->getElementType()->isDoubleTy()" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1742, __PRETTY_FUNCTION__)); | |||
1743 | for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) { | |||
1744 | union { | |||
1745 | double F; | |||
1746 | uint64_t I; | |||
1747 | }; | |||
1748 | ||||
1749 | F = CDS->getElementAsDouble(i); | |||
1750 | if (AP.isVerbose()) | |||
1751 | AP.OutStreamer.GetCommentOS() << "double " << F << '\n'; | |||
1752 | AP.OutStreamer.EmitIntValue(I, 8); | |||
1753 | } | |||
1754 | } | |||
1755 | ||||
1756 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1757 | unsigned Size = DL.getTypeAllocSize(CDS->getType()); | |||
1758 | unsigned EmittedSize = DL.getTypeAllocSize(CDS->getType()->getElementType()) * | |||
1759 | CDS->getNumElements(); | |||
1760 | if (unsigned Padding = Size - EmittedSize) | |||
1761 | AP.OutStreamer.EmitZeros(Padding); | |||
1762 | ||||
1763 | } | |||
1764 | ||||
1765 | static void emitGlobalConstantArray(const ConstantArray *CA, AsmPrinter &AP) { | |||
1766 | // See if we can aggregate some values. Make sure it can be | |||
1767 | // represented as a series of bytes of the constant value. | |||
1768 | int Value = isRepeatedByteSequence(CA, AP.TM); | |||
1769 | ||||
1770 | if (Value != -1) { | |||
1771 | uint64_t Bytes = | |||
1772 | AP.TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize( | |||
1773 | CA->getType()); | |||
1774 | AP.OutStreamer.EmitFill(Bytes, Value); | |||
1775 | } | |||
1776 | else { | |||
1777 | for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) | |||
1778 | emitGlobalConstantImpl(CA->getOperand(i), AP); | |||
1779 | } | |||
1780 | } | |||
1781 | ||||
1782 | static void emitGlobalConstantVector(const ConstantVector *CV, AsmPrinter &AP) { | |||
1783 | for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) | |||
1784 | emitGlobalConstantImpl(CV->getOperand(i), AP); | |||
1785 | ||||
1786 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1787 | unsigned Size = DL.getTypeAllocSize(CV->getType()); | |||
1788 | unsigned EmittedSize = DL.getTypeAllocSize(CV->getType()->getElementType()) * | |||
1789 | CV->getType()->getNumElements(); | |||
1790 | if (unsigned Padding = Size - EmittedSize) | |||
1791 | AP.OutStreamer.EmitZeros(Padding); | |||
1792 | } | |||
1793 | ||||
1794 | static void emitGlobalConstantStruct(const ConstantStruct *CS, AsmPrinter &AP) { | |||
1795 | // Print the fields in successive locations. Pad to align if needed! | |||
1796 | const DataLayout *DL = AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1797 | unsigned Size = DL->getTypeAllocSize(CS->getType()); | |||
1798 | const StructLayout *Layout = DL->getStructLayout(CS->getType()); | |||
1799 | uint64_t SizeSoFar = 0; | |||
1800 | for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { | |||
1801 | const Constant *Field = CS->getOperand(i); | |||
1802 | ||||
1803 | // Check if padding is needed and insert one or more 0s. | |||
1804 | uint64_t FieldSize = DL->getTypeAllocSize(Field->getType()); | |||
1805 | uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) | |||
1806 | - Layout->getElementOffset(i)) - FieldSize; | |||
1807 | SizeSoFar += FieldSize + PadSize; | |||
1808 | ||||
1809 | // Now print the actual field value. | |||
1810 | emitGlobalConstantImpl(Field, AP); | |||
1811 | ||||
1812 | // Insert padding - this may include padding to increase the size of the | |||
1813 | // current field up to the ABI size (if the struct is not packed) as well | |||
1814 | // as padding to ensure that the next field starts at the right offset. | |||
1815 | AP.OutStreamer.EmitZeros(PadSize); | |||
1816 | } | |||
1817 | assert(SizeSoFar == Layout->getSizeInBytes() &&((SizeSoFar == Layout->getSizeInBytes() && "Layout of constant struct may be incorrect!" ) ? static_cast<void> (0) : __assert_fail ("SizeSoFar == Layout->getSizeInBytes() && \"Layout of constant struct may be incorrect!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1818, __PRETTY_FUNCTION__)) | |||
1818 | "Layout of constant struct may be incorrect!")((SizeSoFar == Layout->getSizeInBytes() && "Layout of constant struct may be incorrect!" ) ? static_cast<void> (0) : __assert_fail ("SizeSoFar == Layout->getSizeInBytes() && \"Layout of constant struct may be incorrect!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1818, __PRETTY_FUNCTION__)); | |||
1819 | } | |||
1820 | ||||
1821 | static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) { | |||
1822 | APInt API = CFP->getValueAPF().bitcastToAPInt(); | |||
1823 | ||||
1824 | // First print a comment with what we think the original floating-point value | |||
1825 | // should have been. | |||
1826 | if (AP.isVerbose()) { | |||
1827 | SmallString<8> StrVal; | |||
1828 | CFP->getValueAPF().toString(StrVal); | |||
1829 | ||||
1830 | if (CFP->getType()) | |||
1831 | CFP->getType()->print(AP.OutStreamer.GetCommentOS()); | |||
1832 | else | |||
1833 | AP.OutStreamer.GetCommentOS() << "Printing <null> Type"; | |||
1834 | AP.OutStreamer.GetCommentOS() << ' ' << StrVal << '\n'; | |||
1835 | } | |||
1836 | ||||
1837 | // Now iterate through the APInt chunks, emitting them in endian-correct | |||
1838 | // order, possibly with a smaller chunk at beginning/end (e.g. for x87 80-bit | |||
1839 | // floats). | |||
1840 | unsigned NumBytes = API.getBitWidth() / 8; | |||
1841 | unsigned TrailingBytes = NumBytes % sizeof(uint64_t); | |||
1842 | const uint64_t *p = API.getRawData(); | |||
1843 | ||||
1844 | // PPC's long double has odd notions of endianness compared to how LLVM | |||
1845 | // handles it: p[0] goes first for *big* endian on PPC. | |||
1846 | if (AP.TM.getSubtargetImpl()->getDataLayout()->isBigEndian() && | |||
1847 | !CFP->getType()->isPPC_FP128Ty()) { | |||
1848 | int Chunk = API.getNumWords() - 1; | |||
1849 | ||||
1850 | if (TrailingBytes) | |||
1851 | AP.OutStreamer.EmitIntValue(p[Chunk--], TrailingBytes); | |||
1852 | ||||
1853 | for (; Chunk >= 0; --Chunk) | |||
1854 | AP.OutStreamer.EmitIntValue(p[Chunk], sizeof(uint64_t)); | |||
1855 | } else { | |||
1856 | unsigned Chunk; | |||
1857 | for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk) | |||
1858 | AP.OutStreamer.EmitIntValue(p[Chunk], sizeof(uint64_t)); | |||
1859 | ||||
1860 | if (TrailingBytes) | |||
1861 | AP.OutStreamer.EmitIntValue(p[Chunk], TrailingBytes); | |||
1862 | } | |||
1863 | ||||
1864 | // Emit the tail padding for the long double. | |||
1865 | const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1866 | AP.OutStreamer.EmitZeros(DL.getTypeAllocSize(CFP->getType()) - | |||
1867 | DL.getTypeStoreSize(CFP->getType())); | |||
1868 | } | |||
1869 | ||||
1870 | static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) { | |||
1871 | const DataLayout *DL = AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1872 | unsigned BitWidth = CI->getBitWidth(); | |||
1873 | ||||
1874 | // Copy the value as we may massage the layout for constants whose bit width | |||
1875 | // is not a multiple of 64-bits. | |||
1876 | APInt Realigned(CI->getValue()); | |||
1877 | uint64_t ExtraBits = 0; | |||
1878 | unsigned ExtraBitsSize = BitWidth & 63; | |||
1879 | ||||
1880 | if (ExtraBitsSize) { | |||
1881 | // The bit width of the data is not a multiple of 64-bits. | |||
1882 | // The extra bits are expected to be at the end of the chunk of the memory. | |||
1883 | // Little endian: | |||
1884 | // * Nothing to be done, just record the extra bits to emit. | |||
1885 | // Big endian: | |||
1886 | // * Record the extra bits to emit. | |||
1887 | // * Realign the raw data to emit the chunks of 64-bits. | |||
1888 | if (DL->isBigEndian()) { | |||
1889 | // Basically the structure of the raw data is a chunk of 64-bits cells: | |||
1890 | // 0 1 BitWidth / 64 | |||
1891 | // [chunk1][chunk2] ... [chunkN]. | |||
1892 | // The most significant chunk is chunkN and it should be emitted first. | |||
1893 | // However, due to the alignment issue chunkN contains useless bits. | |||
1894 | // Realign the chunks so that they contain only useless information: | |||
1895 | // ExtraBits 0 1 (BitWidth / 64) - 1 | |||
1896 | // chu[nk1 chu][nk2 chu] ... [nkN-1 chunkN] | |||
1897 | ExtraBits = Realigned.getRawData()[0] & | |||
1898 | (((uint64_t)-1) >> (64 - ExtraBitsSize)); | |||
1899 | Realigned = Realigned.lshr(ExtraBitsSize); | |||
1900 | } else | |||
1901 | ExtraBits = Realigned.getRawData()[BitWidth / 64]; | |||
1902 | } | |||
1903 | ||||
1904 | // We don't expect assemblers to support integer data directives | |||
1905 | // for more than 64 bits, so we emit the data in at most 64-bit | |||
1906 | // quantities at a time. | |||
1907 | const uint64_t *RawData = Realigned.getRawData(); | |||
1908 | for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { | |||
1909 | uint64_t Val = DL->isBigEndian() ? RawData[e - i - 1] : RawData[i]; | |||
1910 | AP.OutStreamer.EmitIntValue(Val, 8); | |||
1911 | } | |||
1912 | ||||
1913 | if (ExtraBitsSize) { | |||
1914 | // Emit the extra bits after the 64-bits chunks. | |||
1915 | ||||
1916 | // Emit a directive that fills the expected size. | |||
1917 | uint64_t Size = AP.TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize( | |||
1918 | CI->getType()); | |||
1919 | Size -= (BitWidth / 64) * 8; | |||
1920 | assert(Size && Size * 8 >= ExtraBitsSize &&((Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && "Directive too small for extra bits.") ? static_cast <void> (0) : __assert_fail ("Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && \"Directive too small for extra bits.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1922, __PRETTY_FUNCTION__)) | |||
1921 | (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))((Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && "Directive too small for extra bits.") ? static_cast <void> (0) : __assert_fail ("Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && \"Directive too small for extra bits.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1922, __PRETTY_FUNCTION__)) | |||
1922 | == ExtraBits && "Directive too small for extra bits.")((Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && "Directive too small for extra bits.") ? static_cast <void> (0) : __assert_fail ("Size && Size * 8 >= ExtraBitsSize && (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) == ExtraBits && \"Directive too small for extra bits.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 1922, __PRETTY_FUNCTION__)); | |||
1923 | AP.OutStreamer.EmitIntValue(ExtraBits, Size); | |||
1924 | } | |||
1925 | } | |||
1926 | ||||
1927 | static void emitGlobalConstantImpl(const Constant *CV, AsmPrinter &AP) { | |||
1928 | const DataLayout *DL = AP.TM.getSubtargetImpl()->getDataLayout(); | |||
1929 | uint64_t Size = DL->getTypeAllocSize(CV->getType()); | |||
1930 | if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) | |||
1931 | return AP.OutStreamer.EmitZeros(Size); | |||
1932 | ||||
1933 | if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { | |||
1934 | switch (Size) { | |||
1935 | case 1: | |||
1936 | case 2: | |||
1937 | case 4: | |||
1938 | case 8: | |||
1939 | if (AP.isVerbose()) | |||
1940 | AP.OutStreamer.GetCommentOS() << format("0x%" PRIx64"l" "x" "\n", | |||
1941 | CI->getZExtValue()); | |||
1942 | AP.OutStreamer.EmitIntValue(CI->getZExtValue(), Size); | |||
1943 | return; | |||
1944 | default: | |||
1945 | emitGlobalConstantLargeInt(CI, AP); | |||
1946 | return; | |||
1947 | } | |||
1948 | } | |||
1949 | ||||
1950 | if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) | |||
1951 | return emitGlobalConstantFP(CFP, AP); | |||
1952 | ||||
1953 | if (isa<ConstantPointerNull>(CV)) { | |||
1954 | AP.OutStreamer.EmitIntValue(0, Size); | |||
1955 | return; | |||
1956 | } | |||
1957 | ||||
1958 | if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV)) | |||
1959 | return emitGlobalConstantDataSequential(CDS, AP); | |||
1960 | ||||
1961 | if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) | |||
1962 | return emitGlobalConstantArray(CVA, AP); | |||
1963 | ||||
1964 | if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) | |||
1965 | return emitGlobalConstantStruct(CVS, AP); | |||
1966 | ||||
1967 | if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { | |||
1968 | // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of | |||
1969 | // vectors). | |||
1970 | if (CE->getOpcode() == Instruction::BitCast) | |||
1971 | return emitGlobalConstantImpl(CE->getOperand(0), AP); | |||
1972 | ||||
1973 | if (Size > 8) { | |||
1974 | // If the constant expression's size is greater than 64-bits, then we have | |||
1975 | // to emit the value in chunks. Try to constant fold the value and emit it | |||
1976 | // that way. | |||
1977 | Constant *New = ConstantFoldConstantExpression(CE, DL); | |||
1978 | if (New && New != CE) | |||
1979 | return emitGlobalConstantImpl(New, AP); | |||
1980 | } | |||
1981 | } | |||
1982 | ||||
1983 | if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) | |||
1984 | return emitGlobalConstantVector(V, AP); | |||
1985 | ||||
1986 | // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it | |||
1987 | // thread the streamer with EmitValue. | |||
1988 | AP.OutStreamer.EmitValue(lowerConstant(CV, AP), Size); | |||
1989 | } | |||
1990 | ||||
1991 | /// EmitGlobalConstant - Print a general LLVM constant to the .s file. | |||
1992 | void AsmPrinter::EmitGlobalConstant(const Constant *CV) { | |||
1993 | uint64_t Size = | |||
1994 | TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize(CV->getType()); | |||
1995 | if (Size) | |||
1996 | emitGlobalConstantImpl(CV, *this); | |||
1997 | else if (MAI->hasSubsectionsViaSymbols()) { | |||
1998 | // If the global has zero size, emit a single byte so that two labels don't | |||
1999 | // look like they are at the same location. | |||
2000 | OutStreamer.EmitIntValue(0, 1); | |||
2001 | } | |||
2002 | } | |||
2003 | ||||
2004 | void AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { | |||
2005 | // Target doesn't support this yet! | |||
2006 | llvm_unreachable("Target does not support EmitMachineConstantPoolValue")::llvm::llvm_unreachable_internal("Target does not support EmitMachineConstantPoolValue" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 2006); | |||
2007 | } | |||
2008 | ||||
2009 | void AsmPrinter::printOffset(int64_t Offset, raw_ostream &OS) const { | |||
2010 | if (Offset > 0) | |||
2011 | OS << '+' << Offset; | |||
2012 | else if (Offset < 0) | |||
2013 | OS << Offset; | |||
2014 | } | |||
2015 | ||||
2016 | //===----------------------------------------------------------------------===// | |||
2017 | // Symbol Lowering Routines. | |||
2018 | //===----------------------------------------------------------------------===// | |||
2019 | ||||
2020 | /// GetTempSymbol - Return the MCSymbol corresponding to the assembler | |||
2021 | /// temporary label with the specified stem and unique ID. | |||
2022 | MCSymbol *AsmPrinter::GetTempSymbol(Twine Name, unsigned ID) const { | |||
2023 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
2024 | return OutContext.GetOrCreateSymbol(Twine(DL->getPrivateGlobalPrefix()) + | |||
2025 | Name + Twine(ID)); | |||
2026 | } | |||
2027 | ||||
2028 | /// GetTempSymbol - Return an assembler temporary label with the specified | |||
2029 | /// stem. | |||
2030 | MCSymbol *AsmPrinter::GetTempSymbol(Twine Name) const { | |||
2031 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
2032 | return OutContext.GetOrCreateSymbol(Twine(DL->getPrivateGlobalPrefix())+ | |||
2033 | Name); | |||
2034 | } | |||
2035 | ||||
2036 | ||||
2037 | MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const { | |||
2038 | return MMI->getAddrLabelSymbol(BA->getBasicBlock()); | |||
2039 | } | |||
2040 | ||||
2041 | MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const { | |||
2042 | return MMI->getAddrLabelSymbol(BB); | |||
2043 | } | |||
2044 | ||||
2045 | /// GetCPISymbol - Return the symbol for the specified constant pool entry. | |||
2046 | MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { | |||
2047 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
2048 | return OutContext.GetOrCreateSymbol | |||
2049 | (Twine(DL->getPrivateGlobalPrefix()) + "CPI" + Twine(getFunctionNumber()) | |||
2050 | + "_" + Twine(CPID)); | |||
2051 | } | |||
2052 | ||||
2053 | /// GetJTISymbol - Return the symbol for the specified jump table entry. | |||
2054 | MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { | |||
2055 | return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate); | |||
2056 | } | |||
2057 | ||||
2058 | /// GetJTSetSymbol - Return the symbol for the specified jump table .set | |||
2059 | /// FIXME: privatize to AsmPrinter. | |||
2060 | MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { | |||
2061 | const DataLayout *DL = TM.getSubtargetImpl()->getDataLayout(); | |||
2062 | return OutContext.GetOrCreateSymbol | |||
2063 | (Twine(DL->getPrivateGlobalPrefix()) + Twine(getFunctionNumber()) + "_" + | |||
2064 | Twine(UID) + "_set_" + Twine(MBBID)); | |||
2065 | } | |||
2066 | ||||
2067 | MCSymbol *AsmPrinter::getSymbolWithGlobalValueBase(const GlobalValue *GV, | |||
2068 | StringRef Suffix) const { | |||
2069 | return getObjFileLowering().getSymbolWithGlobalValueBase(GV, Suffix, *Mang, | |||
2070 | TM); | |||
2071 | } | |||
2072 | ||||
2073 | /// GetExternalSymbolSymbol - Return the MCSymbol for the specified | |||
2074 | /// ExternalSymbol. | |||
2075 | MCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { | |||
2076 | SmallString<60> NameStr; | |||
2077 | Mang->getNameWithPrefix(NameStr, Sym); | |||
2078 | return OutContext.GetOrCreateSymbol(NameStr.str()); | |||
2079 | } | |||
2080 | ||||
2081 | ||||
2082 | ||||
2083 | /// PrintParentLoopComment - Print comments about parent loops of this one. | |||
2084 | static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, | |||
2085 | unsigned FunctionNumber) { | |||
2086 | if (!Loop) return; | |||
2087 | PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); | |||
2088 | OS.indent(Loop->getLoopDepth()*2) | |||
2089 | << "Parent Loop BB" << FunctionNumber << "_" | |||
2090 | << Loop->getHeader()->getNumber() | |||
2091 | << " Depth=" << Loop->getLoopDepth() << '\n'; | |||
2092 | } | |||
2093 | ||||
2094 | ||||
2095 | /// PrintChildLoopComment - Print comments about child loops within | |||
2096 | /// the loop for this basic block, with nesting. | |||
2097 | static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, | |||
2098 | unsigned FunctionNumber) { | |||
2099 | // Add child loop information | |||
2100 | for (const MachineLoop *CL : *Loop) { | |||
2101 | OS.indent(CL->getLoopDepth()*2) | |||
2102 | << "Child Loop BB" << FunctionNumber << "_" | |||
2103 | << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth() | |||
2104 | << '\n'; | |||
2105 | PrintChildLoopComment(OS, CL, FunctionNumber); | |||
2106 | } | |||
2107 | } | |||
2108 | ||||
2109 | /// emitBasicBlockLoopComments - Pretty-print comments for basic blocks. | |||
2110 | static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, | |||
2111 | const MachineLoopInfo *LI, | |||
2112 | const AsmPrinter &AP) { | |||
2113 | // Add loop depth information | |||
2114 | const MachineLoop *Loop = LI->getLoopFor(&MBB); | |||
2115 | if (!Loop) return; | |||
2116 | ||||
2117 | MachineBasicBlock *Header = Loop->getHeader(); | |||
2118 | assert(Header && "No header for loop")((Header && "No header for loop") ? static_cast<void > (0) : __assert_fail ("Header && \"No header for loop\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn224240/lib/CodeGen/AsmPrinter/AsmPrinter.cpp" , 2118, __PRETTY_FUNCTION__)); | |||
2119 | ||||
2120 | // If this block is not a loop header, just print out what is the loop header | |||
2121 | // and return. | |||
2122 | if (Header != &MBB) { | |||
2123 | AP.OutStreamer.AddComment(" in Loop: Header=BB" + | |||
2124 | Twine(AP.getFunctionNumber())+"_" + | |||
2125 | Twine(Loop->getHeader()->getNumber())+ | |||
2126 | " Depth="+Twine(Loop->getLoopDepth())); | |||
2127 | return; | |||
2128 | } | |||
2129 | ||||
2130 | // Otherwise, it is a loop header. Print out information about child and | |||
2131 | // parent loops. | |||
2132 | raw_ostream &OS = AP.OutStreamer.GetCommentOS(); | |||
2133 | ||||
2134 | PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); | |||
2135 | ||||
2136 | OS << "=>"; | |||
2137 | OS.indent(Loop->getLoopDepth()*2-2); | |||
2138 | ||||
2139 | OS << "This "; | |||
2140 | if (Loop->empty()) | |||
2141 | OS << "Inner "; | |||
2142 | OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; | |||
2143 | ||||
2144 | PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); | |||
2145 | } | |||
2146 | ||||
2147 | ||||
2148 | /// EmitBasicBlockStart - This method prints the label for the specified | |||
2149 | /// MachineBasicBlock, an alignment (if present) and a comment describing | |||
2150 | /// it if appropriate. | |||
2151 | void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) const { | |||
2152 | // Emit an alignment directive for this block, if needed. | |||
2153 | if (unsigned Align = MBB.getAlignment()) | |||
2154 | EmitAlignment(Align); | |||
2155 | ||||
2156 | // If the block has its address taken, emit any labels that were used to | |||
2157 | // reference the block. It is possible that there is more than one label | |||
2158 | // here, because multiple LLVM BB's may have been RAUW'd to this block after | |||
2159 | // the references were generated. | |||
2160 | if (MBB.hasAddressTaken()) { | |||
2161 | const BasicBlock *BB = MBB.getBasicBlock(); | |||
2162 | if (isVerbose()) | |||
2163 | OutStreamer.AddComment("Block address taken"); | |||
2164 | ||||
2165 | std::vector<MCSymbol*> Symbols = MMI->getAddrLabelSymbolToEmit(BB); | |||
2166 | for (auto *Sym : Symbols) | |||
2167 | OutStreamer.EmitLabel(Sym); | |||
2168 | } | |||
2169 | ||||
2170 | // Print some verbose block comments. | |||
2171 | if (isVerbose()) { | |||
2172 | if (const BasicBlock *BB = MBB.getBasicBlock()) | |||
2173 | if (BB->hasName()) | |||
2174 | OutStreamer.AddComment("%" + BB->getName()); | |||
2175 | emitBasicBlockLoopComments(MBB, LI, *this); | |||
2176 | } | |||
2177 | ||||
2178 | // Print the main label for the block. | |||
2179 | if (MBB.pred_empty() || isBlockOnlyReachableByFallthrough(&MBB)) { | |||
2180 | if (isVerbose()) { | |||
2181 | // NOTE: Want this comment at start of line, don't emit with AddComment. | |||
2182 | OutStreamer.emitRawComment(" BB#" + Twine(MBB.getNumber()) + ":", false); | |||
2183 | } | |||
2184 | } else { | |||
2185 | OutStreamer.EmitLabel(MBB.getSymbol()); | |||
2186 | } | |||
2187 | } | |||
2188 | ||||
2189 | void AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility, | |||
2190 | bool IsDefinition) const { | |||
2191 | MCSymbolAttr Attr = MCSA_Invalid; | |||
2192 | ||||
2193 | switch (Visibility) { | |||
2194 | default: break; | |||
2195 | case GlobalValue::HiddenVisibility: | |||
2196 | if (IsDefinition) | |||
2197 | Attr = MAI->getHiddenVisibilityAttr(); | |||
2198 | else | |||
2199 | Attr = MAI->getHiddenDeclarationVisibilityAttr(); | |||
2200 | break; | |||
2201 | case GlobalValue::ProtectedVisibility: | |||
2202 | Attr = MAI->getProtectedVisibilityAttr(); | |||
2203 | break; | |||
2204 | } | |||
2205 | ||||
2206 | if (Attr != MCSA_Invalid) | |||
2207 | OutStreamer.EmitSymbolAttribute(Sym, Attr); | |||
2208 | } | |||
2209 | ||||
2210 | /// isBlockOnlyReachableByFallthough - Return true if the basic block has | |||
2211 | /// exactly one predecessor and the control transfer mechanism between | |||
2212 | /// the predecessor and this block is a fall-through. | |||
2213 | bool AsmPrinter:: | |||
2214 | isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { | |||
2215 | // If this is a landing pad, it isn't a fall through. If it has no preds, | |||
2216 | // then nothing falls through to it. | |||
2217 | if (MBB->isLandingPad() || MBB->pred_empty()) | |||
2218 | return false; | |||
2219 | ||||
2220 | // If there isn't exactly one predecessor, it can't be a fall through. | |||
2221 | if (MBB->pred_size() > 1) | |||
2222 | return false; | |||
2223 | ||||
2224 | // The predecessor has to be immediately before this block. | |||
2225 | MachineBasicBlock *Pred = *MBB->pred_begin(); | |||
2226 | if (!Pred->isLayoutSuccessor(MBB)) | |||
2227 | return false; | |||
2228 | ||||
2229 | // If the block is completely empty, then it definitely does fall through. | |||
2230 | if (Pred->empty()) | |||
2231 | return true; | |||
2232 | ||||
2233 | // Check the terminators in the previous blocks | |||
2234 | for (const auto &MI : Pred->terminators()) { | |||
2235 | // If it is not a simple branch, we are in a table somewhere. | |||
2236 | if (!MI.isBranch() || MI.isIndirectBranch()) | |||
2237 | return false; | |||
2238 | ||||
2239 | // If we are the operands of one of the branches, this is not a fall | |||
2240 | // through. Note that targets with delay slots will usually bundle | |||
2241 | // terminators with the delay slot instruction. | |||
2242 | for (ConstMIBundleOperands OP(&MI); OP.isValid(); ++OP) { | |||
2243 | if (OP->isJTI()) | |||
2244 | return false; | |||
2245 | if (OP->isMBB() && OP->getMBB() == MBB) | |||
2246 | return false; | |||
2247 | } | |||
2248 | } | |||
2249 | ||||
2250 | return true; | |||
2251 | } | |||
2252 | ||||
2253 | ||||
2254 | ||||
2255 | GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy &S) { | |||
2256 | if (!S.usesMetadata()) | |||
2257 | return nullptr; | |||
2258 | ||||
2259 | gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); | |||
2260 | gcp_map_type::iterator GCPI = GCMap.find(&S); | |||
2261 | if (GCPI != GCMap.end()) | |||
2262 | return GCPI->second.get(); | |||
2263 | ||||
2264 | const char *Name = S.getName().c_str(); | |||
2265 | ||||
2266 | for (GCMetadataPrinterRegistry::iterator | |||
2267 | I = GCMetadataPrinterRegistry::begin(), | |||
2268 | E = GCMetadataPrinterRegistry::end(); I != E; ++I) | |||
2269 | if (strcmp(Name, I->getName()) == 0) { | |||
2270 | std::unique_ptr<GCMetadataPrinter> GMP = I->instantiate(); | |||
2271 | GMP->S = &S; | |||
2272 | auto IterBool = GCMap.insert(std::make_pair(&S, std::move(GMP))); | |||
2273 | return IterBool.first->second.get(); | |||
2274 | } | |||
2275 | ||||
2276 | report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); | |||
2277 | } | |||
2278 | ||||
2279 | /// Pin vtable to this file. | |||
2280 | AsmPrinterHandler::~AsmPrinterHandler() {} |