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