AsmPrinter.cpp revision 11ae9e29a98595c1899047a64f621fbe46ce7015
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#define DEBUG_TYPE "asm-printer" 15#include "llvm/CodeGen/AsmPrinter.h" 16#include "DwarfDebug.h" 17#include "DwarfException.h" 18#include "llvm/Module.h" 19#include "llvm/CodeGen/GCMetadataPrinter.h" 20#include "llvm/CodeGen/MachineConstantPool.h" 21#include "llvm/CodeGen/MachineFrameInfo.h" 22#include "llvm/CodeGen/MachineFunction.h" 23#include "llvm/CodeGen/MachineJumpTableInfo.h" 24#include "llvm/CodeGen/MachineLoopInfo.h" 25#include "llvm/CodeGen/MachineModuleInfo.h" 26#include "llvm/Analysis/ConstantFolding.h" 27#include "llvm/Analysis/DebugInfo.h" 28#include "llvm/MC/MCAsmInfo.h" 29#include "llvm/MC/MCContext.h" 30#include "llvm/MC/MCExpr.h" 31#include "llvm/MC/MCInst.h" 32#include "llvm/MC/MCSection.h" 33#include "llvm/MC/MCStreamer.h" 34#include "llvm/MC/MCSymbol.h" 35#include "llvm/Target/Mangler.h" 36#include "llvm/Target/TargetData.h" 37#include "llvm/Target/TargetInstrInfo.h" 38#include "llvm/Target/TargetLowering.h" 39#include "llvm/Target/TargetLoweringObjectFile.h" 40#include "llvm/Target/TargetRegisterInfo.h" 41#include "llvm/ADT/SmallString.h" 42#include "llvm/ADT/Statistic.h" 43#include "llvm/Support/ErrorHandling.h" 44#include "llvm/Support/Format.h" 45#include "llvm/Support/Timer.h" 46using namespace llvm; 47 48static const char *DWARFGroupName = "DWARF Emission"; 49static const char *DbgTimerName = "DWARF Debug Writer"; 50static const char *EHTimerName = "DWARF Exception Writer"; 51 52STATISTIC(EmittedInsts, "Number of machine instrs printed"); 53 54char AsmPrinter::ID = 0; 55 56typedef DenseMap<GCStrategy*,GCMetadataPrinter*> gcp_map_type; 57static gcp_map_type &getGCMap(void *&P) { 58 if (P == 0) 59 P = new gcp_map_type(); 60 return *(gcp_map_type*)P; 61} 62 63 64/// getGVAlignmentLog2 - Return the alignment to use for the specified global 65/// value in log2 form. This rounds up to the preferred alignment if possible 66/// and legal. 67static unsigned getGVAlignmentLog2(const GlobalValue *GV, const TargetData &TD, 68 unsigned InBits = 0) { 69 unsigned NumBits = 0; 70 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) 71 NumBits = TD.getPreferredAlignmentLog(GVar); 72 73 // If InBits is specified, round it to it. 74 if (InBits > NumBits) 75 NumBits = InBits; 76 77 // If the GV has a specified alignment, take it into account. 78 if (GV->getAlignment() == 0) 79 return NumBits; 80 81 unsigned GVAlign = Log2_32(GV->getAlignment()); 82 83 // If the GVAlign is larger than NumBits, or if we are required to obey 84 // NumBits because the GV has an assigned section, obey it. 85 if (GVAlign > NumBits || GV->hasSection()) 86 NumBits = GVAlign; 87 return NumBits; 88} 89 90 91 92 93AsmPrinter::AsmPrinter(TargetMachine &tm, MCStreamer &Streamer) 94 : MachineFunctionPass(ID), 95 TM(tm), MAI(tm.getMCAsmInfo()), 96 OutContext(Streamer.getContext()), 97 OutStreamer(Streamer), 98 LastMI(0), LastFn(0), Counter(~0U), SetCounter(0) { 99 DD = 0; DE = 0; MMI = 0; LI = 0; 100 GCMetadataPrinters = 0; 101 VerboseAsm = Streamer.isVerboseAsm(); 102} 103 104AsmPrinter::~AsmPrinter() { 105 assert(DD == 0 && DE == 0 && "Debug/EH info didn't get finalized"); 106 107 if (GCMetadataPrinters != 0) { 108 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); 109 110 for (gcp_map_type::iterator I = GCMap.begin(), E = GCMap.end(); I != E; ++I) 111 delete I->second; 112 delete &GCMap; 113 GCMetadataPrinters = 0; 114 } 115 116 delete &OutStreamer; 117} 118 119/// getFunctionNumber - Return a unique ID for the current function. 120/// 121unsigned AsmPrinter::getFunctionNumber() const { 122 return MF->getFunctionNumber(); 123} 124 125const TargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { 126 return TM.getTargetLowering()->getObjFileLowering(); 127} 128 129 130/// getTargetData - Return information about data layout. 131const TargetData &AsmPrinter::getTargetData() const { 132 return *TM.getTargetData(); 133} 134 135/// getCurrentSection() - Return the current section we are emitting to. 136const MCSection *AsmPrinter::getCurrentSection() const { 137 return OutStreamer.getCurrentSection(); 138} 139 140 141 142void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { 143 AU.setPreservesAll(); 144 MachineFunctionPass::getAnalysisUsage(AU); 145 AU.addRequired<MachineModuleInfo>(); 146 AU.addRequired<GCModuleInfo>(); 147 if (isVerbose()) 148 AU.addRequired<MachineLoopInfo>(); 149} 150 151bool AsmPrinter::doInitialization(Module &M) { 152 MMI = getAnalysisIfAvailable<MachineModuleInfo>(); 153 MMI->AnalyzeModule(M); 154 155 // Initialize TargetLoweringObjectFile. 156 const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) 157 .Initialize(OutContext, TM); 158 159 Mang = new Mangler(OutContext, *TM.getTargetData()); 160 161 // Allow the target to emit any magic that it wants at the start of the file. 162 EmitStartOfAsmFile(M); 163 164 // Very minimal debug info. It is ignored if we emit actual debug info. If we 165 // don't, this at least helps the user find where a global came from. 166 if (MAI->hasSingleParameterDotFile()) { 167 // .file "foo.c" 168 OutStreamer.EmitFileDirective(M.getModuleIdentifier()); 169 } 170 171 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 172 assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 173 for (GCModuleInfo::iterator I = MI->begin(), E = MI->end(); I != E; ++I) 174 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 175 MP->beginAssembly(*this); 176 177 // Emit module-level inline asm if it exists. 178 if (!M.getModuleInlineAsm().empty()) { 179 OutStreamer.AddComment("Start of file scope inline assembly"); 180 OutStreamer.AddBlankLine(); 181 EmitInlineAsm(M.getModuleInlineAsm()+"\n"); 182 OutStreamer.AddComment("End of file scope inline assembly"); 183 OutStreamer.AddBlankLine(); 184 } 185 186 if (MAI->doesSupportDebugInformation()) 187 DD = new DwarfDebug(this, &M); 188 189 if (MAI->doesSupportExceptionHandling()) 190 DE = new DwarfException(this); 191 192 return false; 193} 194 195void AsmPrinter::EmitLinkage(unsigned Linkage, MCSymbol *GVSym) const { 196 switch ((GlobalValue::LinkageTypes)Linkage) { 197 case GlobalValue::CommonLinkage: 198 case GlobalValue::LinkOnceAnyLinkage: 199 case GlobalValue::LinkOnceODRLinkage: 200 case GlobalValue::WeakAnyLinkage: 201 case GlobalValue::WeakODRLinkage: 202 case GlobalValue::LinkerPrivateWeakLinkage: 203 case GlobalValue::LinkerPrivateWeakDefAutoLinkage: 204 if (MAI->getWeakDefDirective() != 0) { 205 // .globl _foo 206 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 207 208 if ((GlobalValue::LinkageTypes)Linkage != 209 GlobalValue::LinkerPrivateWeakDefAutoLinkage) 210 // .weak_definition _foo 211 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefinition); 212 else 213 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate); 214 } else if (MAI->getLinkOnceDirective() != 0) { 215 // .globl _foo 216 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 217 //NOTE: linkonce is handled by the section the symbol was assigned to. 218 } else { 219 // .weak _foo 220 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Weak); 221 } 222 break; 223 case GlobalValue::DLLExportLinkage: 224 case GlobalValue::AppendingLinkage: 225 // FIXME: appending linkage variables should go into a section of 226 // their name or something. For now, just emit them as external. 227 case GlobalValue::ExternalLinkage: 228 // If external or appending, declare as a global symbol. 229 // .globl _foo 230 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 231 break; 232 case GlobalValue::PrivateLinkage: 233 case GlobalValue::InternalLinkage: 234 case GlobalValue::LinkerPrivateLinkage: 235 break; 236 default: 237 llvm_unreachable("Unknown linkage type!"); 238 } 239} 240 241 242/// EmitGlobalVariable - Emit the specified global variable to the .s file. 243void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) { 244 if (!GV->hasInitializer()) // External globals require no code. 245 return; 246 247 // Check to see if this is a special global used by LLVM, if so, emit it. 248 if (EmitSpecialLLVMGlobal(GV)) 249 return; 250 251 if (isVerbose()) { 252 WriteAsOperand(OutStreamer.GetCommentOS(), GV, 253 /*PrintType=*/false, GV->getParent()); 254 OutStreamer.GetCommentOS() << '\n'; 255 } 256 257 MCSymbol *GVSym = Mang->getSymbol(GV); 258 EmitVisibility(GVSym, GV->getVisibility()); 259 260 if (MAI->hasDotTypeDotSizeDirective()) 261 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); 262 263 SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); 264 265 const TargetData *TD = TM.getTargetData(); 266 uint64_t Size = TD->getTypeAllocSize(GV->getType()->getElementType()); 267 268 // If the alignment is specified, we *must* obey it. Overaligning a global 269 // with a specified alignment is a prompt way to break globals emitted to 270 // sections and expected to be contiguous (e.g. ObjC metadata). 271 unsigned AlignLog = getGVAlignmentLog2(GV, *TD); 272 273 // Handle common and BSS local symbols (.lcomm). 274 if (GVKind.isCommon() || GVKind.isBSSLocal()) { 275 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. 276 277 if (isVerbose()) { 278 WriteAsOperand(OutStreamer.GetCommentOS(), GV, 279 /*PrintType=*/false, GV->getParent()); 280 OutStreamer.GetCommentOS() << '\n'; 281 } 282 283 // Handle common symbols. 284 if (GVKind.isCommon()) { 285 unsigned Align = 1 << AlignLog; 286 if (!getObjFileLowering().getCommDirectiveSupportsAlignment()) 287 Align = 0; 288 289 // .comm _foo, 42, 4 290 OutStreamer.EmitCommonSymbol(GVSym, Size, Align); 291 return; 292 } 293 294 // Handle local BSS symbols. 295 if (MAI->hasMachoZeroFillDirective()) { 296 const MCSection *TheSection = 297 getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 298 // .zerofill __DATA, __bss, _foo, 400, 5 299 OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 300 return; 301 } 302 303 if (MAI->hasLCOMMDirective()) { 304 // .lcomm _foo, 42 305 OutStreamer.EmitLocalCommonSymbol(GVSym, Size); 306 return; 307 } 308 309 unsigned Align = 1 << AlignLog; 310 if (!getObjFileLowering().getCommDirectiveSupportsAlignment()) 311 Align = 0; 312 313 // .local _foo 314 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Local); 315 // .comm _foo, 42, 4 316 OutStreamer.EmitCommonSymbol(GVSym, Size, Align); 317 return; 318 } 319 320 const MCSection *TheSection = 321 getObjFileLowering().SectionForGlobal(GV, GVKind, Mang, TM); 322 323 // Handle the zerofill directive on darwin, which is a special form of BSS 324 // emission. 325 if (GVKind.isBSSExtern() && MAI->hasMachoZeroFillDirective()) { 326 if (Size == 0) Size = 1; // zerofill of 0 bytes is undefined. 327 328 // .globl _foo 329 OutStreamer.EmitSymbolAttribute(GVSym, MCSA_Global); 330 // .zerofill __DATA, __common, _foo, 400, 5 331 OutStreamer.EmitZerofill(TheSection, GVSym, Size, 1 << AlignLog); 332 return; 333 } 334 335 // Handle thread local data for mach-o which requires us to output an 336 // additional structure of data and mangle the original symbol so that we 337 // can reference it later. 338 // 339 // TODO: This should become an "emit thread local global" method on TLOF. 340 // All of this macho specific stuff should be sunk down into TLOFMachO and 341 // stuff like "TLSExtraDataSection" should no longer be part of the parent 342 // TLOF class. This will also make it more obvious that stuff like 343 // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho 344 // specific code. 345 if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) { 346 // Emit the .tbss symbol 347 MCSymbol *MangSym = 348 OutContext.GetOrCreateSymbol(GVSym->getName() + Twine("$tlv$init")); 349 350 if (GVKind.isThreadBSS()) 351 OutStreamer.EmitTBSSSymbol(TheSection, MangSym, Size, 1 << AlignLog); 352 else if (GVKind.isThreadData()) { 353 OutStreamer.SwitchSection(TheSection); 354 355 EmitAlignment(AlignLog, GV); 356 OutStreamer.EmitLabel(MangSym); 357 358 EmitGlobalConstant(GV->getInitializer()); 359 } 360 361 OutStreamer.AddBlankLine(); 362 363 // Emit the variable struct for the runtime. 364 const MCSection *TLVSect 365 = getObjFileLowering().getTLSExtraDataSection(); 366 367 OutStreamer.SwitchSection(TLVSect); 368 // Emit the linkage here. 369 EmitLinkage(GV->getLinkage(), GVSym); 370 OutStreamer.EmitLabel(GVSym); 371 372 // Three pointers in size: 373 // - __tlv_bootstrap - used to make sure support exists 374 // - spare pointer, used when mapped by the runtime 375 // - pointer to mangled symbol above with initializer 376 unsigned PtrSize = TD->getPointerSizeInBits()/8; 377 OutStreamer.EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"), 378 PtrSize, 0); 379 OutStreamer.EmitIntValue(0, PtrSize, 0); 380 OutStreamer.EmitSymbolValue(MangSym, PtrSize, 0); 381 382 OutStreamer.AddBlankLine(); 383 return; 384 } 385 386 OutStreamer.SwitchSection(TheSection); 387 388 EmitLinkage(GV->getLinkage(), GVSym); 389 EmitAlignment(AlignLog, GV); 390 391 OutStreamer.EmitLabel(GVSym); 392 393 EmitGlobalConstant(GV->getInitializer()); 394 395 if (MAI->hasDotTypeDotSizeDirective()) 396 // .size foo, 42 397 OutStreamer.EmitELFSize(GVSym, MCConstantExpr::Create(Size, OutContext)); 398 399 OutStreamer.AddBlankLine(); 400} 401 402/// EmitFunctionHeader - This method emits the header for the current 403/// function. 404void AsmPrinter::EmitFunctionHeader() { 405 // Print out constants referenced by the function 406 EmitConstantPool(); 407 408 // Print the 'header' of function. 409 const Function *F = MF->getFunction(); 410 411 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); 412 EmitVisibility(CurrentFnSym, F->getVisibility()); 413 414 EmitLinkage(F->getLinkage(), CurrentFnSym); 415 EmitAlignment(MF->getAlignment(), F); 416 417 if (MAI->hasDotTypeDotSizeDirective()) 418 OutStreamer.EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction); 419 420 if (isVerbose()) { 421 WriteAsOperand(OutStreamer.GetCommentOS(), F, 422 /*PrintType=*/false, F->getParent()); 423 OutStreamer.GetCommentOS() << '\n'; 424 } 425 426 // Emit the CurrentFnSym. This is a virtual function to allow targets to 427 // do their wild and crazy things as required. 428 EmitFunctionEntryLabel(); 429 430 // If the function had address-taken blocks that got deleted, then we have 431 // references to the dangling symbols. Emit them at the start of the function 432 // so that we don't get references to undefined symbols. 433 std::vector<MCSymbol*> DeadBlockSyms; 434 MMI->takeDeletedSymbolsForFunction(F, DeadBlockSyms); 435 for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) { 436 OutStreamer.AddComment("Address taken block that was later removed"); 437 OutStreamer.EmitLabel(DeadBlockSyms[i]); 438 } 439 440 // Add some workaround for linkonce linkage on Cygwin\MinGW. 441 if (MAI->getLinkOnceDirective() != 0 && 442 (F->hasLinkOnceLinkage() || F->hasWeakLinkage())) { 443 // FIXME: What is this? 444 MCSymbol *FakeStub = 445 OutContext.GetOrCreateSymbol(Twine("Lllvm$workaround$fake$stub$")+ 446 CurrentFnSym->getName()); 447 OutStreamer.EmitLabel(FakeStub); 448 } 449 450 // Emit pre-function debug and/or EH information. 451 if (DE) { 452 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled); 453 DE->BeginFunction(MF); 454 } 455 if (DD) { 456 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 457 DD->beginFunction(MF); 458 } 459} 460 461/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the 462/// function. This can be overridden by targets as required to do custom stuff. 463void AsmPrinter::EmitFunctionEntryLabel() { 464 // The function label could have already been emitted if two symbols end up 465 // conflicting due to asm renaming. Detect this and emit an error. 466 if (CurrentFnSym->isUndefined()) 467 return OutStreamer.EmitLabel(CurrentFnSym); 468 469 report_fatal_error("'" + Twine(CurrentFnSym->getName()) + 470 "' label emitted multiple times to assembly file"); 471} 472 473 474static void EmitDebugLoc(DebugLoc DL, const MachineFunction *MF, 475 raw_ostream &CommentOS) { 476 const LLVMContext &Ctx = MF->getFunction()->getContext(); 477 if (!DL.isUnknown()) { // Print source line info. 478 DIScope Scope(DL.getScope(Ctx)); 479 // Omit the directory, because it's likely to be long and uninteresting. 480 if (Scope.Verify()) 481 CommentOS << Scope.getFilename(); 482 else 483 CommentOS << "<unknown>"; 484 CommentOS << ':' << DL.getLine(); 485 if (DL.getCol() != 0) 486 CommentOS << ':' << DL.getCol(); 487 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx)); 488 if (!InlinedAtDL.isUnknown()) { 489 CommentOS << "[ "; 490 EmitDebugLoc(InlinedAtDL, MF, CommentOS); 491 CommentOS << " ]"; 492 } 493 } 494} 495 496/// EmitComments - Pretty-print comments for instructions. 497static void EmitComments(const MachineInstr &MI, raw_ostream &CommentOS) { 498 const MachineFunction *MF = MI.getParent()->getParent(); 499 const TargetMachine &TM = MF->getTarget(); 500 501 DebugLoc DL = MI.getDebugLoc(); 502 if (!DL.isUnknown()) { // Print source line info. 503 EmitDebugLoc(DL, MF, CommentOS); 504 CommentOS << '\n'; 505 } 506 507 // Check for spills and reloads 508 int FI; 509 510 const MachineFrameInfo *FrameInfo = MF->getFrameInfo(); 511 512 // We assume a single instruction only has a spill or reload, not 513 // both. 514 const MachineMemOperand *MMO; 515 if (TM.getInstrInfo()->isLoadFromStackSlotPostFE(&MI, FI)) { 516 if (FrameInfo->isSpillSlotObjectIndex(FI)) { 517 MMO = *MI.memoperands_begin(); 518 CommentOS << MMO->getSize() << "-byte Reload\n"; 519 } 520 } else if (TM.getInstrInfo()->hasLoadFromStackSlot(&MI, MMO, FI)) { 521 if (FrameInfo->isSpillSlotObjectIndex(FI)) 522 CommentOS << MMO->getSize() << "-byte Folded Reload\n"; 523 } else if (TM.getInstrInfo()->isStoreToStackSlotPostFE(&MI, FI)) { 524 if (FrameInfo->isSpillSlotObjectIndex(FI)) { 525 MMO = *MI.memoperands_begin(); 526 CommentOS << MMO->getSize() << "-byte Spill\n"; 527 } 528 } else if (TM.getInstrInfo()->hasStoreToStackSlot(&MI, MMO, FI)) { 529 if (FrameInfo->isSpillSlotObjectIndex(FI)) 530 CommentOS << MMO->getSize() << "-byte Folded Spill\n"; 531 } 532 533 // Check for spill-induced copies 534 if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse)) 535 CommentOS << " Reload Reuse\n"; 536} 537 538/// EmitImplicitDef - This method emits the specified machine instruction 539/// that is an implicit def. 540static void EmitImplicitDef(const MachineInstr *MI, AsmPrinter &AP) { 541 unsigned RegNo = MI->getOperand(0).getReg(); 542 AP.OutStreamer.AddComment(Twine("implicit-def: ") + 543 AP.TM.getRegisterInfo()->getName(RegNo)); 544 AP.OutStreamer.AddBlankLine(); 545} 546 547static void EmitKill(const MachineInstr *MI, AsmPrinter &AP) { 548 std::string Str = "kill:"; 549 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 550 const MachineOperand &Op = MI->getOperand(i); 551 assert(Op.isReg() && "KILL instruction must have only register operands"); 552 Str += ' '; 553 Str += AP.TM.getRegisterInfo()->getName(Op.getReg()); 554 Str += (Op.isDef() ? "<def>" : "<kill>"); 555 } 556 AP.OutStreamer.AddComment(Str); 557 AP.OutStreamer.AddBlankLine(); 558} 559 560/// EmitDebugValueComment - This method handles the target-independent form 561/// of DBG_VALUE, returning true if it was able to do so. A false return 562/// means the target will need to handle MI in EmitInstruction. 563static bool EmitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) { 564 // This code handles only the 3-operand target-independent form. 565 if (MI->getNumOperands() != 3) 566 return false; 567 568 SmallString<128> Str; 569 raw_svector_ostream OS(Str); 570 OS << '\t' << AP.MAI->getCommentString() << "DEBUG_VALUE: "; 571 572 // cast away const; DIetc do not take const operands for some reason. 573 DIVariable V(const_cast<MDNode*>(MI->getOperand(2).getMetadata())); 574 if (V.getContext().isSubprogram()) 575 OS << DISubprogram(V.getContext()).getDisplayName() << ":"; 576 OS << V.getName() << " <- "; 577 578 // Register or immediate value. Register 0 means undef. 579 if (MI->getOperand(0).isFPImm()) { 580 APFloat APF = APFloat(MI->getOperand(0).getFPImm()->getValueAPF()); 581 if (MI->getOperand(0).getFPImm()->getType()->isFloatTy()) { 582 OS << (double)APF.convertToFloat(); 583 } else if (MI->getOperand(0).getFPImm()->getType()->isDoubleTy()) { 584 OS << APF.convertToDouble(); 585 } else { 586 // There is no good way to print long double. Convert a copy to 587 // double. Ah well, it's only a comment. 588 bool ignored; 589 APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 590 &ignored); 591 OS << "(long double) " << APF.convertToDouble(); 592 } 593 } else if (MI->getOperand(0).isImm()) { 594 OS << MI->getOperand(0).getImm(); 595 } else { 596 assert(MI->getOperand(0).isReg() && "Unknown operand type"); 597 if (MI->getOperand(0).getReg() == 0) { 598 // Suppress offset, it is not meaningful here. 599 OS << "undef"; 600 // NOTE: Want this comment at start of line, don't emit with AddComment. 601 AP.OutStreamer.EmitRawText(OS.str()); 602 return true; 603 } 604 OS << AP.TM.getRegisterInfo()->getName(MI->getOperand(0).getReg()); 605 } 606 607 OS << '+' << MI->getOperand(1).getImm(); 608 // NOTE: Want this comment at start of line, don't emit with AddComment. 609 AP.OutStreamer.EmitRawText(OS.str()); 610 return true; 611} 612 613/// EmitFunctionBody - This method emits the body and trailer for a 614/// function. 615void AsmPrinter::EmitFunctionBody() { 616 // Emit target-specific gunk before the function body. 617 EmitFunctionBodyStart(); 618 619 bool ShouldPrintDebugScopes = DD && MMI->hasDebugInfo(); 620 621 // Print out code for the function. 622 bool HasAnyRealCode = false; 623 const MachineInstr *LastMI = 0; 624 for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); 625 I != E; ++I) { 626 // Print a label for the basic block. 627 EmitBasicBlockStart(I); 628 for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end(); 629 II != IE; ++II) { 630 LastMI = II; 631 632 // Print the assembly for the instruction. 633 if (!II->isLabel() && !II->isImplicitDef() && !II->isKill() && 634 !II->isDebugValue()) { 635 HasAnyRealCode = true; 636 ++EmittedInsts; 637 } 638 639 if (ShouldPrintDebugScopes) { 640 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 641 DD->beginInstruction(II); 642 } 643 644 if (isVerbose()) 645 EmitComments(*II, OutStreamer.GetCommentOS()); 646 647 switch (II->getOpcode()) { 648 case TargetOpcode::PROLOG_LABEL: 649 case TargetOpcode::EH_LABEL: 650 case TargetOpcode::GC_LABEL: 651 OutStreamer.EmitLabel(II->getOperand(0).getMCSymbol()); 652 break; 653 case TargetOpcode::INLINEASM: 654 EmitInlineAsm(II); 655 break; 656 case TargetOpcode::DBG_VALUE: 657 if (isVerbose()) { 658 if (!EmitDebugValueComment(II, *this)) 659 EmitInstruction(II); 660 } 661 break; 662 case TargetOpcode::IMPLICIT_DEF: 663 if (isVerbose()) EmitImplicitDef(II, *this); 664 break; 665 case TargetOpcode::KILL: 666 if (isVerbose()) EmitKill(II, *this); 667 break; 668 default: 669 EmitInstruction(II); 670 break; 671 } 672 673 if (ShouldPrintDebugScopes) { 674 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 675 DD->endInstruction(II); 676 } 677 } 678 } 679 680 // If the last instruction was a prolog label, then we have a situation where 681 // we emitted a prolog but no function body. This results in the ending prolog 682 // label equaling the end of function label and an invalid "row" in the 683 // FDE. We need to emit a noop in this situation so that the FDE's rows are 684 // valid. 685 bool RequiresNoop = LastMI && LastMI->isPrologLabel(); 686 687 // If the function is empty and the object file uses .subsections_via_symbols, 688 // then we need to emit *something* to the function body to prevent the 689 // labels from collapsing together. Just emit a noop. 690 if ((MAI->hasSubsectionsViaSymbols() && !HasAnyRealCode) || RequiresNoop) { 691 MCInst Noop; 692 TM.getInstrInfo()->getNoopForMachoTarget(Noop); 693 if (Noop.getOpcode()) { 694 OutStreamer.AddComment("avoids zero-length function"); 695 OutStreamer.EmitInstruction(Noop); 696 } else // Target not mc-ized yet. 697 OutStreamer.EmitRawText(StringRef("\tnop\n")); 698 } 699 700 // Emit target-specific gunk after the function body. 701 EmitFunctionBodyEnd(); 702 703 // If the target wants a .size directive for the size of the function, emit 704 // it. 705 if (MAI->hasDotTypeDotSizeDirective()) { 706 // Create a symbol for the end of function, so we can get the size as 707 // difference between the function label and the temp label. 708 MCSymbol *FnEndLabel = OutContext.CreateTempSymbol(); 709 OutStreamer.EmitLabel(FnEndLabel); 710 711 const MCExpr *SizeExp = 712 MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(FnEndLabel, OutContext), 713 MCSymbolRefExpr::Create(CurrentFnSym, OutContext), 714 OutContext); 715 OutStreamer.EmitELFSize(CurrentFnSym, SizeExp); 716 } 717 718 // Emit post-function debug information. 719 if (DD) { 720 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 721 DD->endFunction(MF); 722 } 723 if (DE) { 724 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled); 725 DE->EndFunction(); 726 } 727 MMI->EndFunction(); 728 729 // Print out jump tables referenced by the function. 730 EmitJumpTableInfo(); 731 732 OutStreamer.AddBlankLine(); 733} 734 735/// getDebugValueLocation - Get location information encoded by DBG_VALUE 736/// operands. 737MachineLocation AsmPrinter::getDebugValueLocation(const MachineInstr *MI) const { 738 // Target specific DBG_VALUE instructions are handled by each target. 739 return MachineLocation(); 740} 741 742bool AsmPrinter::doFinalization(Module &M) { 743 // Emit global variables. 744 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 745 I != E; ++I) 746 EmitGlobalVariable(I); 747 748 // Finalize debug and EH information. 749 if (DE) { 750 { 751 NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled); 752 DE->EndModule(); 753 } 754 delete DE; DE = 0; 755 } 756 if (DD) { 757 { 758 NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled); 759 DD->endModule(); 760 } 761 delete DD; DD = 0; 762 } 763 764 // If the target wants to know about weak references, print them all. 765 if (MAI->getWeakRefDirective()) { 766 // FIXME: This is not lazy, it would be nice to only print weak references 767 // to stuff that is actually used. Note that doing so would require targets 768 // to notice uses in operands (due to constant exprs etc). This should 769 // happen with the MC stuff eventually. 770 771 // Print out module-level global variables here. 772 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 773 I != E; ++I) { 774 if (!I->hasExternalWeakLinkage()) continue; 775 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(I), MCSA_WeakReference); 776 } 777 778 for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) { 779 if (!I->hasExternalWeakLinkage()) continue; 780 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(I), MCSA_WeakReference); 781 } 782 } 783 784 if (MAI->hasSetDirective()) { 785 OutStreamer.AddBlankLine(); 786 for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end(); 787 I != E; ++I) { 788 MCSymbol *Name = Mang->getSymbol(I); 789 790 const GlobalValue *GV = cast<GlobalValue>(I->getAliasedGlobal()); 791 MCSymbol *Target = Mang->getSymbol(GV); 792 793 if (I->hasExternalLinkage() || !MAI->getWeakRefDirective()) 794 OutStreamer.EmitSymbolAttribute(Name, MCSA_Global); 795 else if (I->hasWeakLinkage()) 796 OutStreamer.EmitSymbolAttribute(Name, MCSA_WeakReference); 797 else 798 assert(I->hasLocalLinkage() && "Invalid alias linkage"); 799 800 EmitVisibility(Name, I->getVisibility()); 801 802 // Emit the directives as assignments aka .set: 803 OutStreamer.EmitAssignment(Name, 804 MCSymbolRefExpr::Create(Target, OutContext)); 805 } 806 } 807 808 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 809 assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 810 for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) 811 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*--I)) 812 MP->finishAssembly(*this); 813 814 // If we don't have any trampolines, then we don't require stack memory 815 // to be executable. Some targets have a directive to declare this. 816 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); 817 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) 818 if (const MCSection *S = MAI->getNonexecutableStackSection(OutContext)) 819 OutStreamer.SwitchSection(S); 820 821 // Allow the target to emit any magic that it wants at the end of the file, 822 // after everything else has gone out. 823 EmitEndOfAsmFile(M); 824 825 delete Mang; Mang = 0; 826 MMI = 0; 827 828 OutStreamer.Finish(); 829 return false; 830} 831 832void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { 833 this->MF = &MF; 834 // Get the function symbol. 835 CurrentFnSym = Mang->getSymbol(MF.getFunction()); 836 837 if (isVerbose()) 838 LI = &getAnalysis<MachineLoopInfo>(); 839} 840 841namespace { 842 // SectionCPs - Keep track the alignment, constpool entries per Section. 843 struct SectionCPs { 844 const MCSection *S; 845 unsigned Alignment; 846 SmallVector<unsigned, 4> CPEs; 847 SectionCPs(const MCSection *s, unsigned a) : S(s), Alignment(a) {} 848 }; 849} 850 851/// EmitConstantPool - Print to the current output stream assembly 852/// representations of the constants in the constant pool MCP. This is 853/// used to print out constants which have been "spilled to memory" by 854/// the code generator. 855/// 856void AsmPrinter::EmitConstantPool() { 857 const MachineConstantPool *MCP = MF->getConstantPool(); 858 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); 859 if (CP.empty()) return; 860 861 // Calculate sections for constant pool entries. We collect entries to go into 862 // the same section together to reduce amount of section switch statements. 863 SmallVector<SectionCPs, 4> CPSections; 864 for (unsigned i = 0, e = CP.size(); i != e; ++i) { 865 const MachineConstantPoolEntry &CPE = CP[i]; 866 unsigned Align = CPE.getAlignment(); 867 868 SectionKind Kind; 869 switch (CPE.getRelocationInfo()) { 870 default: llvm_unreachable("Unknown section kind"); 871 case 2: Kind = SectionKind::getReadOnlyWithRel(); break; 872 case 1: 873 Kind = SectionKind::getReadOnlyWithRelLocal(); 874 break; 875 case 0: 876 switch (TM.getTargetData()->getTypeAllocSize(CPE.getType())) { 877 case 4: Kind = SectionKind::getMergeableConst4(); break; 878 case 8: Kind = SectionKind::getMergeableConst8(); break; 879 case 16: Kind = SectionKind::getMergeableConst16();break; 880 default: Kind = SectionKind::getMergeableConst(); break; 881 } 882 } 883 884 const MCSection *S = getObjFileLowering().getSectionForConstant(Kind); 885 886 // The number of sections are small, just do a linear search from the 887 // last section to the first. 888 bool Found = false; 889 unsigned SecIdx = CPSections.size(); 890 while (SecIdx != 0) { 891 if (CPSections[--SecIdx].S == S) { 892 Found = true; 893 break; 894 } 895 } 896 if (!Found) { 897 SecIdx = CPSections.size(); 898 CPSections.push_back(SectionCPs(S, Align)); 899 } 900 901 if (Align > CPSections[SecIdx].Alignment) 902 CPSections[SecIdx].Alignment = Align; 903 CPSections[SecIdx].CPEs.push_back(i); 904 } 905 906 // Now print stuff into the calculated sections. 907 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { 908 OutStreamer.SwitchSection(CPSections[i].S); 909 EmitAlignment(Log2_32(CPSections[i].Alignment)); 910 911 unsigned Offset = 0; 912 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { 913 unsigned CPI = CPSections[i].CPEs[j]; 914 MachineConstantPoolEntry CPE = CP[CPI]; 915 916 // Emit inter-object padding for alignment. 917 unsigned AlignMask = CPE.getAlignment() - 1; 918 unsigned NewOffset = (Offset + AlignMask) & ~AlignMask; 919 OutStreamer.EmitFill(NewOffset - Offset, 0/*fillval*/, 0/*addrspace*/); 920 921 const Type *Ty = CPE.getType(); 922 Offset = NewOffset + TM.getTargetData()->getTypeAllocSize(Ty); 923 OutStreamer.EmitLabel(GetCPISymbol(CPI)); 924 925 if (CPE.isMachineConstantPoolEntry()) 926 EmitMachineConstantPoolValue(CPE.Val.MachineCPVal); 927 else 928 EmitGlobalConstant(CPE.Val.ConstVal); 929 } 930 } 931} 932 933/// EmitJumpTableInfo - Print assembly representations of the jump tables used 934/// by the current function to the current output stream. 935/// 936void AsmPrinter::EmitJumpTableInfo() { 937 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); 938 if (MJTI == 0) return; 939 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return; 940 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 941 if (JT.empty()) return; 942 943 // Pick the directive to use to print the jump table entries, and switch to 944 // the appropriate section. 945 const Function *F = MF->getFunction(); 946 bool JTInDiffSection = false; 947 if (// In PIC mode, we need to emit the jump table to the same section as the 948 // function body itself, otherwise the label differences won't make sense. 949 // FIXME: Need a better predicate for this: what about custom entries? 950 MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 || 951 // We should also do if the section name is NULL or function is declared 952 // in discardable section 953 // FIXME: this isn't the right predicate, should be based on the MCSection 954 // for the function. 955 F->isWeakForLinker()) { 956 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F,Mang,TM)); 957 } else { 958 // Otherwise, drop it in the readonly section. 959 const MCSection *ReadOnlySection = 960 getObjFileLowering().getSectionForConstant(SectionKind::getReadOnly()); 961 OutStreamer.SwitchSection(ReadOnlySection); 962 JTInDiffSection = true; 963 } 964 965 EmitAlignment(Log2_32(MJTI->getEntryAlignment(*TM.getTargetData()))); 966 967 for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) { 968 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 969 970 // If this jump table was deleted, ignore it. 971 if (JTBBs.empty()) continue; 972 973 // For the EK_LabelDifference32 entry, if the target supports .set, emit a 974 // .set directive for each unique entry. This reduces the number of 975 // relocations the assembler will generate for the jump table. 976 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 && 977 MAI->hasSetDirective()) { 978 SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets; 979 const TargetLowering *TLI = TM.getTargetLowering(); 980 const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF,JTI,OutContext); 981 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { 982 const MachineBasicBlock *MBB = JTBBs[ii]; 983 if (!EmittedSets.insert(MBB)) continue; 984 985 // .set LJTSet, LBB32-base 986 const MCExpr *LHS = 987 MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); 988 OutStreamer.EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()), 989 MCBinaryExpr::CreateSub(LHS, Base, OutContext)); 990 } 991 } 992 993 // On some targets (e.g. Darwin) we want to emit two consequtive labels 994 // before each jump table. The first label is never referenced, but tells 995 // the assembler and linker the extents of the jump table object. The 996 // second label is actually referenced by the code. 997 if (JTInDiffSection && MAI->getLinkerPrivateGlobalPrefix()[0]) 998 // FIXME: This doesn't have to have any specific name, just any randomly 999 // named and numbered 'l' label would work. Simplify GetJTISymbol. 1000 OutStreamer.EmitLabel(GetJTISymbol(JTI, true)); 1001 1002 OutStreamer.EmitLabel(GetJTISymbol(JTI)); 1003 1004 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) 1005 EmitJumpTableEntry(MJTI, JTBBs[ii], JTI); 1006 } 1007} 1008 1009/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the 1010/// current stream. 1011void AsmPrinter::EmitJumpTableEntry(const MachineJumpTableInfo *MJTI, 1012 const MachineBasicBlock *MBB, 1013 unsigned UID) const { 1014 const MCExpr *Value = 0; 1015 switch (MJTI->getEntryKind()) { 1016 case MachineJumpTableInfo::EK_Inline: 1017 llvm_unreachable("Cannot emit EK_Inline jump table entry"); break; 1018 case MachineJumpTableInfo::EK_Custom32: 1019 Value = TM.getTargetLowering()->LowerCustomJumpTableEntry(MJTI, MBB, UID, 1020 OutContext); 1021 break; 1022 case MachineJumpTableInfo::EK_BlockAddress: 1023 // EK_BlockAddress - Each entry is a plain address of block, e.g.: 1024 // .word LBB123 1025 Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); 1026 break; 1027 case MachineJumpTableInfo::EK_GPRel32BlockAddress: { 1028 // EK_GPRel32BlockAddress - Each entry is an address of block, encoded 1029 // with a relocation as gp-relative, e.g.: 1030 // .gprel32 LBB123 1031 MCSymbol *MBBSym = MBB->getSymbol(); 1032 OutStreamer.EmitGPRel32Value(MCSymbolRefExpr::Create(MBBSym, OutContext)); 1033 return; 1034 } 1035 1036 case MachineJumpTableInfo::EK_LabelDifference32: { 1037 // EK_LabelDifference32 - Each entry is the address of the block minus 1038 // the address of the jump table. This is used for PIC jump tables where 1039 // gprel32 is not supported. e.g.: 1040 // .word LBB123 - LJTI1_2 1041 // If the .set directive is supported, this is emitted as: 1042 // .set L4_5_set_123, LBB123 - LJTI1_2 1043 // .word L4_5_set_123 1044 1045 // If we have emitted set directives for the jump table entries, print 1046 // them rather than the entries themselves. If we're emitting PIC, then 1047 // emit the table entries as differences between two text section labels. 1048 if (MAI->hasSetDirective()) { 1049 // If we used .set, reference the .set's symbol. 1050 Value = MCSymbolRefExpr::Create(GetJTSetSymbol(UID, MBB->getNumber()), 1051 OutContext); 1052 break; 1053 } 1054 // Otherwise, use the difference as the jump table entry. 1055 Value = MCSymbolRefExpr::Create(MBB->getSymbol(), OutContext); 1056 const MCExpr *JTI = MCSymbolRefExpr::Create(GetJTISymbol(UID), OutContext); 1057 Value = MCBinaryExpr::CreateSub(Value, JTI, OutContext); 1058 break; 1059 } 1060 } 1061 1062 assert(Value && "Unknown entry kind!"); 1063 1064 unsigned EntrySize = MJTI->getEntrySize(*TM.getTargetData()); 1065 OutStreamer.EmitValue(Value, EntrySize, /*addrspace*/0); 1066} 1067 1068 1069/// EmitSpecialLLVMGlobal - Check to see if the specified global is a 1070/// special global used by LLVM. If so, emit it and return true, otherwise 1071/// do nothing and return false. 1072bool AsmPrinter::EmitSpecialLLVMGlobal(const GlobalVariable *GV) { 1073 if (GV->getName() == "llvm.used") { 1074 if (MAI->hasNoDeadStrip()) // No need to emit this at all. 1075 EmitLLVMUsedList(GV->getInitializer()); 1076 return true; 1077 } 1078 1079 // Ignore debug and non-emitted data. This handles llvm.compiler.used. 1080 if (GV->getSection() == "llvm.metadata" || 1081 GV->hasAvailableExternallyLinkage()) 1082 return true; 1083 1084 if (!GV->hasAppendingLinkage()) return false; 1085 1086 assert(GV->hasInitializer() && "Not a special LLVM global!"); 1087 1088 const TargetData *TD = TM.getTargetData(); 1089 unsigned Align = Log2_32(TD->getPointerPrefAlignment()); 1090 if (GV->getName() == "llvm.global_ctors") { 1091 OutStreamer.SwitchSection(getObjFileLowering().getStaticCtorSection()); 1092 EmitAlignment(Align); 1093 EmitXXStructorList(GV->getInitializer()); 1094 1095 if (TM.getRelocationModel() == Reloc::Static && 1096 MAI->hasStaticCtorDtorReferenceInStaticMode()) { 1097 StringRef Sym(".constructors_used"); 1098 OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 1099 MCSA_Reference); 1100 } 1101 return true; 1102 } 1103 1104 if (GV->getName() == "llvm.global_dtors") { 1105 OutStreamer.SwitchSection(getObjFileLowering().getStaticDtorSection()); 1106 EmitAlignment(Align); 1107 EmitXXStructorList(GV->getInitializer()); 1108 1109 if (TM.getRelocationModel() == Reloc::Static && 1110 MAI->hasStaticCtorDtorReferenceInStaticMode()) { 1111 StringRef Sym(".destructors_used"); 1112 OutStreamer.EmitSymbolAttribute(OutContext.GetOrCreateSymbol(Sym), 1113 MCSA_Reference); 1114 } 1115 return true; 1116 } 1117 1118 return false; 1119} 1120 1121/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each 1122/// global in the specified llvm.used list for which emitUsedDirectiveFor 1123/// is true, as being used with this directive. 1124void AsmPrinter::EmitLLVMUsedList(Constant *List) { 1125 // Should be an array of 'i8*'. 1126 ConstantArray *InitList = dyn_cast<ConstantArray>(List); 1127 if (InitList == 0) return; 1128 1129 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 1130 const GlobalValue *GV = 1131 dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); 1132 if (GV && getObjFileLowering().shouldEmitUsedDirectiveFor(GV, Mang)) 1133 OutStreamer.EmitSymbolAttribute(Mang->getSymbol(GV), MCSA_NoDeadStrip); 1134 } 1135} 1136 1137/// EmitXXStructorList - Emit the ctor or dtor list. This just prints out the 1138/// function pointers, ignoring the init priority. 1139void AsmPrinter::EmitXXStructorList(Constant *List) { 1140 // Should be an array of '{ int, void ()* }' structs. The first value is the 1141 // init priority, which we ignore. 1142 if (!isa<ConstantArray>(List)) return; 1143 ConstantArray *InitList = cast<ConstantArray>(List); 1144 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 1145 if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){ 1146 if (CS->getNumOperands() != 2) return; // Not array of 2-element structs. 1147 1148 if (CS->getOperand(1)->isNullValue()) 1149 return; // Found a null terminator, exit printing. 1150 // Emit the function pointer. 1151 EmitGlobalConstant(CS->getOperand(1)); 1152 } 1153} 1154 1155//===--------------------------------------------------------------------===// 1156// Emission and print routines 1157// 1158 1159/// EmitInt8 - Emit a byte directive and value. 1160/// 1161void AsmPrinter::EmitInt8(int Value) const { 1162 OutStreamer.EmitIntValue(Value, 1, 0/*addrspace*/); 1163} 1164 1165/// EmitInt16 - Emit a short directive and value. 1166/// 1167void AsmPrinter::EmitInt16(int Value) const { 1168 OutStreamer.EmitIntValue(Value, 2, 0/*addrspace*/); 1169} 1170 1171/// EmitInt32 - Emit a long directive and value. 1172/// 1173void AsmPrinter::EmitInt32(int Value) const { 1174 OutStreamer.EmitIntValue(Value, 4, 0/*addrspace*/); 1175} 1176 1177/// EmitLabelDifference - Emit something like ".long Hi-Lo" where the size 1178/// in bytes of the directive is specified by Size and Hi/Lo specify the 1179/// labels. This implicitly uses .set if it is available. 1180void AsmPrinter::EmitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, 1181 unsigned Size) const { 1182 // Get the Hi-Lo expression. 1183 const MCExpr *Diff = 1184 MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(Hi, OutContext), 1185 MCSymbolRefExpr::Create(Lo, OutContext), 1186 OutContext); 1187 1188 if (!MAI->hasSetDirective()) { 1189 OutStreamer.EmitValue(Diff, Size, 0/*AddrSpace*/); 1190 return; 1191 } 1192 1193 // Otherwise, emit with .set (aka assignment). 1194 MCSymbol *SetLabel = GetTempSymbol("set", SetCounter++); 1195 OutStreamer.EmitAssignment(SetLabel, Diff); 1196 OutStreamer.EmitSymbolValue(SetLabel, Size, 0/*AddrSpace*/); 1197} 1198 1199/// EmitLabelOffsetDifference - Emit something like ".long Hi+Offset-Lo" 1200/// where the size in bytes of the directive is specified by Size and Hi/Lo 1201/// specify the labels. This implicitly uses .set if it is available. 1202void AsmPrinter::EmitLabelOffsetDifference(const MCSymbol *Hi, uint64_t Offset, 1203 const MCSymbol *Lo, unsigned Size) 1204 const { 1205 1206 // Emit Hi+Offset - Lo 1207 // Get the Hi+Offset expression. 1208 const MCExpr *Plus = 1209 MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Hi, OutContext), 1210 MCConstantExpr::Create(Offset, OutContext), 1211 OutContext); 1212 1213 // Get the Hi+Offset-Lo expression. 1214 const MCExpr *Diff = 1215 MCBinaryExpr::CreateSub(Plus, 1216 MCSymbolRefExpr::Create(Lo, OutContext), 1217 OutContext); 1218 1219 if (!MAI->hasSetDirective()) 1220 OutStreamer.EmitValue(Diff, 4, 0/*AddrSpace*/); 1221 else { 1222 // Otherwise, emit with .set (aka assignment). 1223 MCSymbol *SetLabel = GetTempSymbol("set", SetCounter++); 1224 OutStreamer.EmitAssignment(SetLabel, Diff); 1225 OutStreamer.EmitSymbolValue(SetLabel, 4, 0/*AddrSpace*/); 1226 } 1227} 1228 1229/// EmitLabelPlusOffset - Emit something like ".long Label+Offset" 1230/// where the size in bytes of the directive is specified by Size and Label 1231/// specifies the label. This implicitly uses .set if it is available. 1232void AsmPrinter::EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, 1233 unsigned Size) 1234 const { 1235 1236 // Emit Label+Offset 1237 const MCExpr *Plus = 1238 MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Label, OutContext), 1239 MCConstantExpr::Create(Offset, OutContext), 1240 OutContext); 1241 1242 OutStreamer.EmitValue(Plus, 4, 0/*AddrSpace*/); 1243} 1244 1245 1246//===----------------------------------------------------------------------===// 1247 1248// EmitAlignment - Emit an alignment directive to the specified power of 1249// two boundary. For example, if you pass in 3 here, you will get an 8 1250// byte alignment. If a global value is specified, and if that global has 1251// an explicit alignment requested, it will override the alignment request 1252// if required for correctness. 1253// 1254void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV) const { 1255 if (GV) NumBits = getGVAlignmentLog2(GV, *TM.getTargetData(), NumBits); 1256 1257 if (NumBits == 0) return; // 1-byte aligned: no need to emit alignment. 1258 1259 if (getCurrentSection()->getKind().isText()) 1260 OutStreamer.EmitCodeAlignment(1 << NumBits); 1261 else 1262 OutStreamer.EmitValueToAlignment(1 << NumBits, 0, 1, 0); 1263} 1264 1265//===----------------------------------------------------------------------===// 1266// Constant emission. 1267//===----------------------------------------------------------------------===// 1268 1269/// LowerConstant - Lower the specified LLVM Constant to an MCExpr. 1270/// 1271static const MCExpr *LowerConstant(const Constant *CV, AsmPrinter &AP) { 1272 MCContext &Ctx = AP.OutContext; 1273 1274 if (CV->isNullValue() || isa<UndefValue>(CV)) 1275 return MCConstantExpr::Create(0, Ctx); 1276 1277 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) 1278 return MCConstantExpr::Create(CI->getZExtValue(), Ctx); 1279 1280 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) 1281 return MCSymbolRefExpr::Create(AP.Mang->getSymbol(GV), Ctx); 1282 1283 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) 1284 return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx); 1285 1286 const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); 1287 if (CE == 0) { 1288 llvm_unreachable("Unknown constant value to lower!"); 1289 return MCConstantExpr::Create(0, Ctx); 1290 } 1291 1292 switch (CE->getOpcode()) { 1293 default: 1294 // If the code isn't optimized, there may be outstanding folding 1295 // opportunities. Attempt to fold the expression using TargetData as a 1296 // last resort before giving up. 1297 if (Constant *C = 1298 ConstantFoldConstantExpression(CE, AP.TM.getTargetData())) 1299 if (C != CE) 1300 return LowerConstant(C, AP); 1301 1302 // Otherwise report the problem to the user. 1303 { 1304 std::string S; 1305 raw_string_ostream OS(S); 1306 OS << "Unsupported expression in static initializer: "; 1307 WriteAsOperand(OS, CE, /*PrintType=*/false, 1308 !AP.MF ? 0 : AP.MF->getFunction()->getParent()); 1309 report_fatal_error(OS.str()); 1310 } 1311 return MCConstantExpr::Create(0, Ctx); 1312 case Instruction::GetElementPtr: { 1313 const TargetData &TD = *AP.TM.getTargetData(); 1314 // Generate a symbolic expression for the byte address 1315 const Constant *PtrVal = CE->getOperand(0); 1316 SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end()); 1317 int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), &IdxVec[0], 1318 IdxVec.size()); 1319 1320 const MCExpr *Base = LowerConstant(CE->getOperand(0), AP); 1321 if (Offset == 0) 1322 return Base; 1323 1324 // Truncate/sext the offset to the pointer size. 1325 if (TD.getPointerSizeInBits() != 64) { 1326 int SExtAmount = 64-TD.getPointerSizeInBits(); 1327 Offset = (Offset << SExtAmount) >> SExtAmount; 1328 } 1329 1330 return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx), 1331 Ctx); 1332 } 1333 1334 case Instruction::Trunc: 1335 // We emit the value and depend on the assembler to truncate the generated 1336 // expression properly. This is important for differences between 1337 // blockaddress labels. Since the two labels are in the same function, it 1338 // is reasonable to treat their delta as a 32-bit value. 1339 // FALL THROUGH. 1340 case Instruction::BitCast: 1341 return LowerConstant(CE->getOperand(0), AP); 1342 1343 case Instruction::IntToPtr: { 1344 const TargetData &TD = *AP.TM.getTargetData(); 1345 // Handle casts to pointers by changing them into casts to the appropriate 1346 // integer type. This promotes constant folding and simplifies this code. 1347 Constant *Op = CE->getOperand(0); 1348 Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()), 1349 false/*ZExt*/); 1350 return LowerConstant(Op, AP); 1351 } 1352 1353 case Instruction::PtrToInt: { 1354 const TargetData &TD = *AP.TM.getTargetData(); 1355 // Support only foldable casts to/from pointers that can be eliminated by 1356 // changing the pointer to the appropriately sized integer type. 1357 Constant *Op = CE->getOperand(0); 1358 const Type *Ty = CE->getType(); 1359 1360 const MCExpr *OpExpr = LowerConstant(Op, AP); 1361 1362 // We can emit the pointer value into this slot if the slot is an 1363 // integer slot equal to the size of the pointer. 1364 if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType())) 1365 return OpExpr; 1366 1367 // Otherwise the pointer is smaller than the resultant integer, mask off 1368 // the high bits so we are sure to get a proper truncation if the input is 1369 // a constant expr. 1370 unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType()); 1371 const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx); 1372 return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx); 1373 } 1374 1375 // The MC library also has a right-shift operator, but it isn't consistently 1376 // signed or unsigned between different targets. 1377 case Instruction::Add: 1378 case Instruction::Sub: 1379 case Instruction::Mul: 1380 case Instruction::SDiv: 1381 case Instruction::SRem: 1382 case Instruction::Shl: 1383 case Instruction::And: 1384 case Instruction::Or: 1385 case Instruction::Xor: { 1386 const MCExpr *LHS = LowerConstant(CE->getOperand(0), AP); 1387 const MCExpr *RHS = LowerConstant(CE->getOperand(1), AP); 1388 switch (CE->getOpcode()) { 1389 default: llvm_unreachable("Unknown binary operator constant cast expr"); 1390 case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx); 1391 case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx); 1392 case Instruction::Mul: return MCBinaryExpr::CreateMul(LHS, RHS, Ctx); 1393 case Instruction::SDiv: return MCBinaryExpr::CreateDiv(LHS, RHS, Ctx); 1394 case Instruction::SRem: return MCBinaryExpr::CreateMod(LHS, RHS, Ctx); 1395 case Instruction::Shl: return MCBinaryExpr::CreateShl(LHS, RHS, Ctx); 1396 case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx); 1397 case Instruction::Or: return MCBinaryExpr::CreateOr (LHS, RHS, Ctx); 1398 case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx); 1399 } 1400 } 1401 } 1402} 1403 1404static void EmitGlobalConstantImpl(const Constant *C, unsigned AddrSpace, 1405 AsmPrinter &AP); 1406 1407static void EmitGlobalConstantArray(const ConstantArray *CA, unsigned AddrSpace, 1408 AsmPrinter &AP) { 1409 if (AddrSpace != 0 || !CA->isString()) { 1410 // Not a string. Print the values in successive locations 1411 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 1412 EmitGlobalConstantImpl(CA->getOperand(i), AddrSpace, AP); 1413 return; 1414 } 1415 1416 // Otherwise, it can be emitted as .ascii. 1417 SmallVector<char, 128> TmpVec; 1418 TmpVec.reserve(CA->getNumOperands()); 1419 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) 1420 TmpVec.push_back(cast<ConstantInt>(CA->getOperand(i))->getZExtValue()); 1421 1422 AP.OutStreamer.EmitBytes(StringRef(TmpVec.data(), TmpVec.size()), AddrSpace); 1423} 1424 1425static void EmitGlobalConstantVector(const ConstantVector *CV, 1426 unsigned AddrSpace, AsmPrinter &AP) { 1427 for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) 1428 EmitGlobalConstantImpl(CV->getOperand(i), AddrSpace, AP); 1429} 1430 1431static void EmitGlobalConstantStruct(const ConstantStruct *CS, 1432 unsigned AddrSpace, AsmPrinter &AP) { 1433 // Print the fields in successive locations. Pad to align if needed! 1434 const TargetData *TD = AP.TM.getTargetData(); 1435 unsigned Size = TD->getTypeAllocSize(CS->getType()); 1436 const StructLayout *Layout = TD->getStructLayout(CS->getType()); 1437 uint64_t SizeSoFar = 0; 1438 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { 1439 const Constant *Field = CS->getOperand(i); 1440 1441 // Check if padding is needed and insert one or more 0s. 1442 uint64_t FieldSize = TD->getTypeAllocSize(Field->getType()); 1443 uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) 1444 - Layout->getElementOffset(i)) - FieldSize; 1445 SizeSoFar += FieldSize + PadSize; 1446 1447 // Now print the actual field value. 1448 EmitGlobalConstantImpl(Field, AddrSpace, AP); 1449 1450 // Insert padding - this may include padding to increase the size of the 1451 // current field up to the ABI size (if the struct is not packed) as well 1452 // as padding to ensure that the next field starts at the right offset. 1453 AP.OutStreamer.EmitZeros(PadSize, AddrSpace); 1454 } 1455 assert(SizeSoFar == Layout->getSizeInBytes() && 1456 "Layout of constant struct may be incorrect!"); 1457} 1458 1459static void EmitGlobalConstantFP(const ConstantFP *CFP, unsigned AddrSpace, 1460 AsmPrinter &AP) { 1461 // FP Constants are printed as integer constants to avoid losing 1462 // precision. 1463 if (CFP->getType()->isDoubleTy()) { 1464 if (AP.isVerbose()) { 1465 double Val = CFP->getValueAPF().convertToDouble(); 1466 AP.OutStreamer.GetCommentOS() << "double " << Val << '\n'; 1467 } 1468 1469 uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 1470 AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 1471 return; 1472 } 1473 1474 if (CFP->getType()->isFloatTy()) { 1475 if (AP.isVerbose()) { 1476 float Val = CFP->getValueAPF().convertToFloat(); 1477 AP.OutStreamer.GetCommentOS() << "float " << Val << '\n'; 1478 } 1479 uint64_t Val = CFP->getValueAPF().bitcastToAPInt().getZExtValue(); 1480 AP.OutStreamer.EmitIntValue(Val, 4, AddrSpace); 1481 return; 1482 } 1483 1484 if (CFP->getType()->isX86_FP80Ty()) { 1485 // all long double variants are printed as hex 1486 // API needed to prevent premature destruction 1487 APInt API = CFP->getValueAPF().bitcastToAPInt(); 1488 const uint64_t *p = API.getRawData(); 1489 if (AP.isVerbose()) { 1490 // Convert to double so we can print the approximate val as a comment. 1491 APFloat DoubleVal = CFP->getValueAPF(); 1492 bool ignored; 1493 DoubleVal.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, 1494 &ignored); 1495 AP.OutStreamer.GetCommentOS() << "x86_fp80 ~= " 1496 << DoubleVal.convertToDouble() << '\n'; 1497 } 1498 1499 if (AP.TM.getTargetData()->isBigEndian()) { 1500 AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 1501 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 1502 } else { 1503 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 1504 AP.OutStreamer.EmitIntValue(p[1], 2, AddrSpace); 1505 } 1506 1507 // Emit the tail padding for the long double. 1508 const TargetData &TD = *AP.TM.getTargetData(); 1509 AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) - 1510 TD.getTypeStoreSize(CFP->getType()), AddrSpace); 1511 return; 1512 } 1513 1514 assert(CFP->getType()->isPPC_FP128Ty() && 1515 "Floating point constant type not handled"); 1516 // All long double variants are printed as hex 1517 // API needed to prevent premature destruction. 1518 APInt API = CFP->getValueAPF().bitcastToAPInt(); 1519 const uint64_t *p = API.getRawData(); 1520 if (AP.TM.getTargetData()->isBigEndian()) { 1521 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 1522 AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 1523 } else { 1524 AP.OutStreamer.EmitIntValue(p[1], 8, AddrSpace); 1525 AP.OutStreamer.EmitIntValue(p[0], 8, AddrSpace); 1526 } 1527} 1528 1529static void EmitGlobalConstantLargeInt(const ConstantInt *CI, 1530 unsigned AddrSpace, AsmPrinter &AP) { 1531 const TargetData *TD = AP.TM.getTargetData(); 1532 unsigned BitWidth = CI->getBitWidth(); 1533 assert((BitWidth & 63) == 0 && "only support multiples of 64-bits"); 1534 1535 // We don't expect assemblers to support integer data directives 1536 // for more than 64 bits, so we emit the data in at most 64-bit 1537 // quantities at a time. 1538 const uint64_t *RawData = CI->getValue().getRawData(); 1539 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { 1540 uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i]; 1541 AP.OutStreamer.EmitIntValue(Val, 8, AddrSpace); 1542 } 1543} 1544 1545static void EmitGlobalConstantImpl(const Constant *CV, unsigned AddrSpace, 1546 AsmPrinter &AP) { 1547 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) { 1548 uint64_t Size = AP.TM.getTargetData()->getTypeAllocSize(CV->getType()); 1549 return AP.OutStreamer.EmitZeros(Size, AddrSpace); 1550 } 1551 1552 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 1553 unsigned Size = AP.TM.getTargetData()->getTypeAllocSize(CV->getType()); 1554 switch (Size) { 1555 case 1: 1556 case 2: 1557 case 4: 1558 case 8: 1559 if (AP.isVerbose()) 1560 AP.OutStreamer.GetCommentOS() << format("0x%llx\n", CI->getZExtValue()); 1561 AP.OutStreamer.EmitIntValue(CI->getZExtValue(), Size, AddrSpace); 1562 return; 1563 default: 1564 EmitGlobalConstantLargeInt(CI, AddrSpace, AP); 1565 return; 1566 } 1567 } 1568 1569 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) 1570 return EmitGlobalConstantArray(CVA, AddrSpace, AP); 1571 1572 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) 1573 return EmitGlobalConstantStruct(CVS, AddrSpace, AP); 1574 1575 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) 1576 return EmitGlobalConstantFP(CFP, AddrSpace, AP); 1577 1578 if (isa<ConstantPointerNull>(CV)) { 1579 unsigned Size = AP.TM.getTargetData()->getTypeAllocSize(CV->getType()); 1580 AP.OutStreamer.EmitIntValue(0, Size, AddrSpace); 1581 return; 1582 } 1583 1584 if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) 1585 return EmitGlobalConstantVector(V, AddrSpace, AP); 1586 1587 // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it 1588 // thread the streamer with EmitValue. 1589 AP.OutStreamer.EmitValue(LowerConstant(CV, AP), 1590 AP.TM.getTargetData()->getTypeAllocSize(CV->getType()), 1591 AddrSpace); 1592} 1593 1594/// EmitGlobalConstant - Print a general LLVM constant to the .s file. 1595void AsmPrinter::EmitGlobalConstant(const Constant *CV, unsigned AddrSpace) { 1596 uint64_t Size = TM.getTargetData()->getTypeAllocSize(CV->getType()); 1597 if (Size) 1598 EmitGlobalConstantImpl(CV, AddrSpace, *this); 1599 else if (MAI->hasSubsectionsViaSymbols()) { 1600 // If the global has zero size, emit a single byte so that two labels don't 1601 // look like they are at the same location. 1602 OutStreamer.EmitIntValue(0, 1, AddrSpace); 1603 } 1604} 1605 1606void AsmPrinter::EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { 1607 // Target doesn't support this yet! 1608 llvm_unreachable("Target does not support EmitMachineConstantPoolValue"); 1609} 1610 1611void AsmPrinter::printOffset(int64_t Offset, raw_ostream &OS) const { 1612 if (Offset > 0) 1613 OS << '+' << Offset; 1614 else if (Offset < 0) 1615 OS << Offset; 1616} 1617 1618//===----------------------------------------------------------------------===// 1619// Symbol Lowering Routines. 1620//===----------------------------------------------------------------------===// 1621 1622/// GetTempSymbol - Return the MCSymbol corresponding to the assembler 1623/// temporary label with the specified stem and unique ID. 1624MCSymbol *AsmPrinter::GetTempSymbol(StringRef Name, unsigned ID) const { 1625 return OutContext.GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + 1626 Name + Twine(ID)); 1627} 1628 1629/// GetTempSymbol - Return an assembler temporary label with the specified 1630/// stem. 1631MCSymbol *AsmPrinter::GetTempSymbol(StringRef Name) const { 1632 return OutContext.GetOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix())+ 1633 Name); 1634} 1635 1636 1637MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const { 1638 return MMI->getAddrLabelSymbol(BA->getBasicBlock()); 1639} 1640 1641MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const { 1642 return MMI->getAddrLabelSymbol(BB); 1643} 1644 1645/// GetCPISymbol - Return the symbol for the specified constant pool entry. 1646MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { 1647 return OutContext.GetOrCreateSymbol 1648 (Twine(MAI->getPrivateGlobalPrefix()) + "CPI" + Twine(getFunctionNumber()) 1649 + "_" + Twine(CPID)); 1650} 1651 1652/// GetJTISymbol - Return the symbol for the specified jump table entry. 1653MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { 1654 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate); 1655} 1656 1657/// GetJTSetSymbol - Return the symbol for the specified jump table .set 1658/// FIXME: privatize to AsmPrinter. 1659MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { 1660 return OutContext.GetOrCreateSymbol 1661 (Twine(MAI->getPrivateGlobalPrefix()) + Twine(getFunctionNumber()) + "_" + 1662 Twine(UID) + "_set_" + Twine(MBBID)); 1663} 1664 1665/// GetSymbolWithGlobalValueBase - Return the MCSymbol for a symbol with 1666/// global value name as its base, with the specified suffix, and where the 1667/// symbol is forced to have private linkage if ForcePrivate is true. 1668MCSymbol *AsmPrinter::GetSymbolWithGlobalValueBase(const GlobalValue *GV, 1669 StringRef Suffix, 1670 bool ForcePrivate) const { 1671 SmallString<60> NameStr; 1672 Mang->getNameWithPrefix(NameStr, GV, ForcePrivate); 1673 NameStr.append(Suffix.begin(), Suffix.end()); 1674 return OutContext.GetOrCreateSymbol(NameStr.str()); 1675} 1676 1677/// GetExternalSymbolSymbol - Return the MCSymbol for the specified 1678/// ExternalSymbol. 1679MCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { 1680 SmallString<60> NameStr; 1681 Mang->getNameWithPrefix(NameStr, Sym); 1682 return OutContext.GetOrCreateSymbol(NameStr.str()); 1683} 1684 1685 1686 1687/// PrintParentLoopComment - Print comments about parent loops of this one. 1688static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1689 unsigned FunctionNumber) { 1690 if (Loop == 0) return; 1691 PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); 1692 OS.indent(Loop->getLoopDepth()*2) 1693 << "Parent Loop BB" << FunctionNumber << "_" 1694 << Loop->getHeader()->getNumber() 1695 << " Depth=" << Loop->getLoopDepth() << '\n'; 1696} 1697 1698 1699/// PrintChildLoopComment - Print comments about child loops within 1700/// the loop for this basic block, with nesting. 1701static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, 1702 unsigned FunctionNumber) { 1703 // Add child loop information 1704 for (MachineLoop::iterator CL = Loop->begin(), E = Loop->end();CL != E; ++CL){ 1705 OS.indent((*CL)->getLoopDepth()*2) 1706 << "Child Loop BB" << FunctionNumber << "_" 1707 << (*CL)->getHeader()->getNumber() << " Depth " << (*CL)->getLoopDepth() 1708 << '\n'; 1709 PrintChildLoopComment(OS, *CL, FunctionNumber); 1710 } 1711} 1712 1713/// EmitBasicBlockLoopComments - Pretty-print comments for basic blocks. 1714static void EmitBasicBlockLoopComments(const MachineBasicBlock &MBB, 1715 const MachineLoopInfo *LI, 1716 const AsmPrinter &AP) { 1717 // Add loop depth information 1718 const MachineLoop *Loop = LI->getLoopFor(&MBB); 1719 if (Loop == 0) return; 1720 1721 MachineBasicBlock *Header = Loop->getHeader(); 1722 assert(Header && "No header for loop"); 1723 1724 // If this block is not a loop header, just print out what is the loop header 1725 // and return. 1726 if (Header != &MBB) { 1727 AP.OutStreamer.AddComment(" in Loop: Header=BB" + 1728 Twine(AP.getFunctionNumber())+"_" + 1729 Twine(Loop->getHeader()->getNumber())+ 1730 " Depth="+Twine(Loop->getLoopDepth())); 1731 return; 1732 } 1733 1734 // Otherwise, it is a loop header. Print out information about child and 1735 // parent loops. 1736 raw_ostream &OS = AP.OutStreamer.GetCommentOS(); 1737 1738 PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); 1739 1740 OS << "=>"; 1741 OS.indent(Loop->getLoopDepth()*2-2); 1742 1743 OS << "This "; 1744 if (Loop->empty()) 1745 OS << "Inner "; 1746 OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; 1747 1748 PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); 1749} 1750 1751 1752/// EmitBasicBlockStart - This method prints the label for the specified 1753/// MachineBasicBlock, an alignment (if present) and a comment describing 1754/// it if appropriate. 1755void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock *MBB) const { 1756 // Emit an alignment directive for this block, if needed. 1757 if (unsigned Align = MBB->getAlignment()) 1758 EmitAlignment(Log2_32(Align)); 1759 1760 // If the block has its address taken, emit any labels that were used to 1761 // reference the block. It is possible that there is more than one label 1762 // here, because multiple LLVM BB's may have been RAUW'd to this block after 1763 // the references were generated. 1764 if (MBB->hasAddressTaken()) { 1765 const BasicBlock *BB = MBB->getBasicBlock(); 1766 if (isVerbose()) 1767 OutStreamer.AddComment("Block address taken"); 1768 1769 std::vector<MCSymbol*> Syms = MMI->getAddrLabelSymbolToEmit(BB); 1770 1771 for (unsigned i = 0, e = Syms.size(); i != e; ++i) 1772 OutStreamer.EmitLabel(Syms[i]); 1773 } 1774 1775 // Print the main label for the block. 1776 if (MBB->pred_empty() || isBlockOnlyReachableByFallthrough(MBB)) { 1777 if (isVerbose() && OutStreamer.hasRawTextSupport()) { 1778 if (const BasicBlock *BB = MBB->getBasicBlock()) 1779 if (BB->hasName()) 1780 OutStreamer.AddComment("%" + BB->getName()); 1781 1782 EmitBasicBlockLoopComments(*MBB, LI, *this); 1783 1784 // NOTE: Want this comment at start of line, don't emit with AddComment. 1785 OutStreamer.EmitRawText(Twine(MAI->getCommentString()) + " BB#" + 1786 Twine(MBB->getNumber()) + ":"); 1787 } 1788 } else { 1789 if (isVerbose()) { 1790 if (const BasicBlock *BB = MBB->getBasicBlock()) 1791 if (BB->hasName()) 1792 OutStreamer.AddComment("%" + BB->getName()); 1793 EmitBasicBlockLoopComments(*MBB, LI, *this); 1794 } 1795 1796 OutStreamer.EmitLabel(MBB->getSymbol()); 1797 } 1798} 1799 1800void AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility) const { 1801 MCSymbolAttr Attr = MCSA_Invalid; 1802 1803 switch (Visibility) { 1804 default: break; 1805 case GlobalValue::HiddenVisibility: 1806 Attr = MAI->getHiddenVisibilityAttr(); 1807 break; 1808 case GlobalValue::ProtectedVisibility: 1809 Attr = MAI->getProtectedVisibilityAttr(); 1810 break; 1811 } 1812 1813 if (Attr != MCSA_Invalid) 1814 OutStreamer.EmitSymbolAttribute(Sym, Attr); 1815} 1816 1817/// isBlockOnlyReachableByFallthough - Return true if the basic block has 1818/// exactly one predecessor and the control transfer mechanism between 1819/// the predecessor and this block is a fall-through. 1820bool AsmPrinter:: 1821isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { 1822 // If this is a landing pad, it isn't a fall through. If it has no preds, 1823 // then nothing falls through to it. 1824 if (MBB->isLandingPad() || MBB->pred_empty()) 1825 return false; 1826 1827 // If there isn't exactly one predecessor, it can't be a fall through. 1828 MachineBasicBlock::const_pred_iterator PI = MBB->pred_begin(), PI2 = PI; 1829 ++PI2; 1830 if (PI2 != MBB->pred_end()) 1831 return false; 1832 1833 // The predecessor has to be immediately before this block. 1834 const MachineBasicBlock *Pred = *PI; 1835 1836 if (!Pred->isLayoutSuccessor(MBB)) 1837 return false; 1838 1839 // If the block is completely empty, then it definitely does fall through. 1840 if (Pred->empty()) 1841 return true; 1842 1843 // Otherwise, check the last instruction. 1844 const MachineInstr &LastInst = Pred->back(); 1845 return !LastInst.getDesc().isBarrier(); 1846} 1847 1848 1849 1850GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy *S) { 1851 if (!S->usesMetadata()) 1852 return 0; 1853 1854 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); 1855 gcp_map_type::iterator GCPI = GCMap.find(S); 1856 if (GCPI != GCMap.end()) 1857 return GCPI->second; 1858 1859 const char *Name = S->getName().c_str(); 1860 1861 for (GCMetadataPrinterRegistry::iterator 1862 I = GCMetadataPrinterRegistry::begin(), 1863 E = GCMetadataPrinterRegistry::end(); I != E; ++I) 1864 if (strcmp(Name, I->getName()) == 0) { 1865 GCMetadataPrinter *GMP = I->instantiate(); 1866 GMP->S = S; 1867 GCMap.insert(std::make_pair(S, GMP)); 1868 return GMP; 1869 } 1870 1871 report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); 1872 return 0; 1873} 1874 1875