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