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