lib/CodeGen/AsmPrinter/AsmPrinter.cpp

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