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