lib/CodeGen/AsmPrinter/DwarfDebug.cpp

   1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
   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 contains support for writing dwarf debug info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15 #include "DwarfDebug.h"
  16 #include "DIE.h"
  17 #include "DIEHash.h"
  18 #include "DwarfAccelTable.h"
  19 #include "DwarfCompileUnit.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/Statistic.h"
  22 #include "llvm/ADT/StringExtras.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/DIBuilder.h"
  27 #include "llvm/DebugInfo.h"
  28 #include "llvm/IR/Constants.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/Instructions.h"
  31 #include "llvm/IR/Module.h"
  32 #include "llvm/MC/MCAsmInfo.h"
  33 #include "llvm/MC/MCSection.h"
  34 #include "llvm/MC/MCStreamer.h"
  35 #include "llvm/MC/MCSymbol.h"
  36 #include "llvm/Support/CommandLine.h"
  37 #include "llvm/Support/Debug.h"
  38 #include "llvm/Support/Dwarf.h"
  39 #include "llvm/Support/ErrorHandling.h"
  40 #include "llvm/Support/FormattedStream.h"
  41 #include "llvm/Support/MD5.h"
  42 #include "llvm/Support/Path.h"
  43 #include "llvm/Support/Timer.h"
  44 #include "llvm/Support/ValueHandle.h"
  45 #include "llvm/Target/TargetFrameLowering.h"
  46 #include "llvm/Target/TargetLoweringObjectFile.h"
  47 #include "llvm/Target/TargetMachine.h"
  48 #include "llvm/Target/TargetOptions.h"
  49 #include "llvm/Target/TargetRegisterInfo.h"
  50 using namespace llvm;
  51
  52 static cl::opt<bool>
  53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
  54                          cl::desc("Disable debug info printing"));
  55
  56 static cl::opt<bool> UnknownLocations(
  57     "use-unknown-locations", cl::Hidden,
  58     cl::desc("Make an absence of debug location information explicit."),
  59     cl::init(false));
  60
  61 static cl::opt<bool>
  62 GenerateODRHash("generate-odr-hash", cl::Hidden,
  63                 cl::desc("Add an ODR hash to external type DIEs."),
  64                 cl::init(false));
  65
  66 static cl::opt<bool> GenerateCUHash("generate-cu-hash", cl::Hidden,
  67                                     cl::desc("Add the CU hash as the dwo_id."),
  68                                     cl::init(false));
  69
  70 static cl::opt<bool>
  71 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
  72                        cl::desc("Generate GNU-style pubnames and pubtypes"),
  73                        cl::init(false));
  74
  75 namespace {
  76 enum DefaultOnOff {
  77   Default,
  78   Enable,
  79   Disable
  80 };
  81 }
  82
  83 static cl::opt<DefaultOnOff>
  84 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
  85                  cl::desc("Output prototype dwarf accelerator tables."),
  86                  cl::values(clEnumVal(Default, "Default for platform"),
  87                             clEnumVal(Enable, "Enabled"),
  88                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
  89                  cl::init(Default));
  90
  91 static cl::opt<DefaultOnOff>
  92 SplitDwarf("split-dwarf", cl::Hidden,
  93            cl::desc("Output prototype dwarf split debug info."),
  94            cl::values(clEnumVal(Default, "Default for platform"),
  95                       clEnumVal(Enable, "Enabled"),
  96                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
  97            cl::init(Default));
  98
  99 static cl::opt<DefaultOnOff>
 100 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
 101                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
 102                  cl::values(clEnumVal(Default, "Default for platform"),
 103                             clEnumVal(Enable, "Enabled"),
 104                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
 105                  cl::init(Default));
 106
 107 static cl::opt<unsigned>
 108 DwarfVersionNumber("dwarf-version", cl::Hidden,
 109                    cl::desc("Generate DWARF for dwarf version."),
 110                    cl::init(0));
 111
 112 static const char *const DWARFGroupName = "DWARF Emission";
 113 static const char *const DbgTimerName = "DWARF Debug Writer";
 114
 115 //===----------------------------------------------------------------------===//
 116
 117 // Configuration values for initial hash set sizes (log2).
 118 //
 119 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
 120
 121 namespace llvm {
 122
 123 /// resolve - Look in the DwarfDebug map for the MDNode that
 124 /// corresponds to the reference.
 125 template <typename T> T DbgVariable::resolve(DIRef<T> Ref) const {
 126   return DD->resolve(Ref);
 127 }
 128
 129 DIType DbgVariable::getType() const {
 130   DIType Ty = Var.getType();
 131   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
 132   // addresses instead.
 133   if (Var.isBlockByrefVariable()) {
 134     /* Byref variables, in Blocks, are declared by the programmer as
 135        "SomeType VarName;", but the compiler creates a
 136        __Block_byref_x_VarName struct, and gives the variable VarName
 137        either the struct, or a pointer to the struct, as its type.  This
 138        is necessary for various behind-the-scenes things the compiler
 139        needs to do with by-reference variables in blocks.
 140
 141        However, as far as the original *programmer* is concerned, the
 142        variable should still have type 'SomeType', as originally declared.
 143
 144        The following function dives into the __Block_byref_x_VarName
 145        struct to find the original type of the variable.  This will be
 146        passed back to the code generating the type for the Debug
 147        Information Entry for the variable 'VarName'.  'VarName' will then
 148        have the original type 'SomeType' in its debug information.
 149
 150        The original type 'SomeType' will be the type of the field named
 151        'VarName' inside the __Block_byref_x_VarName struct.
 152
 153        NOTE: In order for this to not completely fail on the debugger
 154        side, the Debug Information Entry for the variable VarName needs to
 155        have a DW_AT_location that tells the debugger how to unwind through
 156        the pointers and __Block_byref_x_VarName struct to find the actual
 157        value of the variable.  The function addBlockByrefType does this.  */
 158     DIType subType = Ty;
 159     uint16_t tag = Ty.getTag();
 160
 161     if (tag == dwarf::DW_TAG_pointer_type)
 162       subType = resolve(DIDerivedType(Ty).getTypeDerivedFrom());
 163
 164     DIArray Elements = DICompositeType(subType).getTypeArray();
 165     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 166       DIDerivedType DT(Elements.getElement(i));
 167       if (getName() == DT.getName())
 168         return (resolve(DT.getTypeDerivedFrom()));
 169     }
 170   }
 171   return Ty;
 172 }
 173
 174 } // end llvm namespace
 175
 176 /// Return Dwarf Version by checking module flags.
 177 static unsigned getDwarfVersionFromModule(const Module *M) {
 178   Value *Val = M->getModuleFlag("Dwarf Version");
 179   if (!Val)
 180     return dwarf::DWARF_VERSION;
 181   return cast<ConstantInt>(Val)->getZExtValue();
 182 }
 183
 184 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 185     : Asm(A), MMI(Asm->MMI), FirstCU(0),
 186       AbbreviationsSet(InitAbbreviationsSetSize),
 187       SourceIdMap(DIEValueAllocator), PrevLabel(NULL), GlobalCUIndexCount(0),
 188       InfoHolder(A, &AbbreviationsSet, Abbreviations, "info_string",
 189                  DIEValueAllocator),
 190       SkeletonAbbrevSet(InitAbbreviationsSetSize),
 191       SkeletonHolder(A, &SkeletonAbbrevSet, SkeletonAbbrevs, "skel_string",
 192                      DIEValueAllocator) {
 193
 194   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 195   DwarfStrSectionSym = TextSectionSym = 0;
 196   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
 197   DwarfAddrSectionSym = 0;
 198   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
 199   FunctionBeginSym = FunctionEndSym = 0;
 200
 201   // Turn on accelerator tables for Darwin by default, pubnames by
 202   // default for non-Darwin, and handle split dwarf.
 203   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
 204
 205   if (DwarfAccelTables == Default)
 206     HasDwarfAccelTables = IsDarwin;
 207   else
 208     HasDwarfAccelTables = DwarfAccelTables == Enable;
 209
 210   if (SplitDwarf == Default)
 211     HasSplitDwarf = false;
 212   else
 213     HasSplitDwarf = SplitDwarf == Enable;
 214
 215   if (DwarfPubSections == Default)
 216     HasDwarfPubSections = !IsDarwin;
 217   else
 218     HasDwarfPubSections = DwarfPubSections == Enable;
 219
 220   DwarfVersion = DwarfVersionNumber
 221                      ? DwarfVersionNumber
 222                      : getDwarfVersionFromModule(MMI->getModule());
 223
 224   {
 225     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
 226     beginModule();
 227   }
 228 }
 229
 230 // Switch to the specified MCSection and emit an assembler
 231 // temporary label to it if SymbolStem is specified.
 232 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
 233                                 const char *SymbolStem = 0) {
 234   Asm->OutStreamer.SwitchSection(Section);
 235   if (!SymbolStem)
 236     return 0;
 237
 238   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
 239   Asm->OutStreamer.EmitLabel(TmpSym);
 240   return TmpSym;
 241 }
 242
 243 DwarfUnits::~DwarfUnits() {
 244   for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
 245        ++I)
 246     delete *I;
 247 }
 248
 249 MCSymbol *DwarfUnits::getStringPoolSym() {
 250   return Asm->GetTempSymbol(StringPref);
 251 }
 252
 253 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
 254   std::pair<MCSymbol *, unsigned> &Entry =
 255       StringPool.GetOrCreateValue(Str).getValue();
 256   if (Entry.first)
 257     return Entry.first;
 258
 259   Entry.second = NextStringPoolNumber++;
 260   return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 261 }
 262
 263 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
 264   std::pair<MCSymbol *, unsigned> &Entry =
 265       StringPool.GetOrCreateValue(Str).getValue();
 266   if (Entry.first)
 267     return Entry.second;
 268
 269   Entry.second = NextStringPoolNumber++;
 270   Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 271   return Entry.second;
 272 }
 273
 274 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
 275   return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
 276 }
 277
 278 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
 279   std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
 280       AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
 281   if (P.second)
 282     ++NextAddrPoolNumber;
 283   return P.first->second;
 284 }
 285
 286 // Define a unique number for the abbreviation.
 287 //
 288 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 289   // Check the set for priors.
 290   DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
 291
 292   // If it's newly added.
 293   if (InSet == &Abbrev) {
 294     // Add to abbreviation list.
 295     Abbreviations.push_back(&Abbrev);
 296
 297     // Assign the vector position + 1 as its number.
 298     Abbrev.setNumber(Abbreviations.size());
 299   } else {
 300     // Assign existing abbreviation number.
 301     Abbrev.setNumber(InSet->getNumber());
 302   }
 303 }
 304
 305 static bool isObjCClass(StringRef Name) {
 306   return Name.startswith("+") || Name.startswith("-");
 307 }
 308
 309 static bool hasObjCCategory(StringRef Name) {
 310   if (!isObjCClass(Name))
 311     return false;
 312
 313   return Name.find(") ") != StringRef::npos;
 314 }
 315
 316 static void getObjCClassCategory(StringRef In, StringRef &Class,
 317                                  StringRef &Category) {
 318   if (!hasObjCCategory(In)) {
 319     Class = In.slice(In.find('[') + 1, In.find(' '));
 320     Category = "";
 321     return;
 322   }
 323
 324   Class = In.slice(In.find('[') + 1, In.find('('));
 325   Category = In.slice(In.find('[') + 1, In.find(' '));
 326   return;
 327 }
 328
 329 static StringRef getObjCMethodName(StringRef In) {
 330   return In.slice(In.find(' ') + 1, In.find(']'));
 331 }
 332
 333 // Helper for sorting sections into a stable output order.
 334 static bool SectionSort(const MCSection *A, const MCSection *B) {
 335   std::string LA = (A ? A->getLabelBeginName() : "");
 336   std::string LB = (B ? B->getLabelBeginName() : "");
 337   return LA < LB;
 338 }
 339
 340 // Add the various names to the Dwarf accelerator table names.
 341 // TODO: Determine whether or not we should add names for programs
 342 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
 343 // is only slightly different than the lookup of non-standard ObjC names.
 344 static void addSubprogramNames(Unit *TheCU, DISubprogram SP, DIE *Die) {
 345   if (!SP.isDefinition())
 346     return;
 347   TheCU->addAccelName(SP.getName(), Die);
 348
 349   // If the linkage name is different than the name, go ahead and output
 350   // that as well into the name table.
 351   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
 352     TheCU->addAccelName(SP.getLinkageName(), Die);
 353
 354   // If this is an Objective-C selector name add it to the ObjC accelerator
 355   // too.
 356   if (isObjCClass(SP.getName())) {
 357     StringRef Class, Category;
 358     getObjCClassCategory(SP.getName(), Class, Category);
 359     TheCU->addAccelObjC(Class, Die);
 360     if (Category != "")
 361       TheCU->addAccelObjC(Category, Die);
 362     // Also add the base method name to the name table.
 363     TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
 364   }
 365 }
 366
 367 /// isSubprogramContext - Return true if Context is either a subprogram
 368 /// or another context nested inside a subprogram.
 369 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
 370   if (!Context)
 371     return false;
 372   DIDescriptor D(Context);
 373   if (D.isSubprogram())
 374     return true;
 375   if (D.isType())
 376     return isSubprogramContext(resolve(DIType(Context).getContext()));
 377   return false;
 378 }
 379
 380 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 381 // and DW_AT_high_pc attributes. If there are global variables in this
 382 // scope then create and insert DIEs for these variables.
 383 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU, DISubprogram SP) {
 384   DIE *SPDie = SPCU->getDIE(SP);
 385
 386   assert(SPDie && "Unable to find subprogram DIE!");
 387
 388   // If we're updating an abstract DIE, then we will be adding the children and
 389   // object pointer later on. But what we don't want to do is process the
 390   // concrete DIE twice.
 391   if (DIE *AbsSPDIE = AbstractSPDies.lookup(SP)) {
 392     // Pick up abstract subprogram DIE.
 393     SPDie = SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getCUDie());
 394     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin, AbsSPDIE);
 395   } else {
 396     DISubprogram SPDecl = SP.getFunctionDeclaration();
 397     if (!SPDecl.isSubprogram()) {
 398       // There is not any need to generate specification DIE for a function
 399       // defined at compile unit level. If a function is defined inside another
 400       // function then gdb prefers the definition at top level and but does not
 401       // expect specification DIE in parent function. So avoid creating
 402       // specification DIE for a function defined inside a function.
 403       DIScope SPContext = resolve(SP.getContext());
 404       if (SP.isDefinition() && !SPContext.isCompileUnit() &&
 405           !SPContext.isFile() && !isSubprogramContext(SPContext)) {
 406         SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
 407
 408         // Add arguments.
 409         DICompositeType SPTy = SP.getType();
 410         DIArray Args = SPTy.getTypeArray();
 411         uint16_t SPTag = SPTy.getTag();
 412         if (SPTag == dwarf::DW_TAG_subroutine_type)
 413           for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 414             DIE *Arg =
 415                 SPCU->createAndAddDIE(dwarf::DW_TAG_formal_parameter, *SPDie);
 416             DIType ATy(Args.getElement(i));
 417             SPCU->addType(Arg, ATy);
 418             if (ATy.isArtificial())
 419               SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
 420             if (ATy.isObjectPointer())
 421               SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer, Arg);
 422           }
 423         DIE *SPDeclDie = SPDie;
 424         SPDie =
 425             SPCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *SPCU->getCUDie());
 426         SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, SPDeclDie);
 427       }
 428     }
 429   }
 430
 431   SPCU->addLabelAddress(
 432       SPDie, dwarf::DW_AT_low_pc,
 433       Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
 434   SPCU->addLabelAddress(
 435       SPDie, dwarf::DW_AT_high_pc,
 436       Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
 437   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 438   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
 439   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
 440
 441   // Add name to the name table, we do this here because we're guaranteed
 442   // to have concrete versions of our DW_TAG_subprogram nodes.
 443   addSubprogramNames(SPCU, SP, SPDie);
 444
 445   return SPDie;
 446 }
 447
 448 /// Check whether we should create a DIE for the given Scope, return true
 449 /// if we don't create a DIE (the corresponding DIE is null).
 450 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
 451   if (Scope->isAbstractScope())
 452     return false;
 453
 454   // We don't create a DIE if there is no Range.
 455   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 456   if (Ranges.empty())
 457     return true;
 458
 459   if (Ranges.size() > 1)
 460     return false;
 461
 462   // We don't create a DIE if we have a single Range and the end label
 463   // is null.
 464   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 465   MCSymbol *End = getLabelAfterInsn(RI->second);
 466   return !End;
 467 }
 468
 469 // Construct new DW_TAG_lexical_block for this scope and attach
 470 // DW_AT_low_pc/DW_AT_high_pc labels.
 471 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
 472                                           LexicalScope *Scope) {
 473   if (isLexicalScopeDIENull(Scope))
 474     return 0;
 475
 476   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
 477   if (Scope->isAbstractScope())
 478     return ScopeDIE;
 479
 480   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 481   // If we have multiple ranges, emit them into the range section.
 482   if (Ranges.size() > 1) {
 483     // .debug_range section has not been laid out yet. Emit offset in
 484     // .debug_range as a relocatable label. emitDIE will handle
 485     // emitting it appropriately.
 486     unsigned Offset = DebugRangeSymbols.size();
 487     TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
 488                            Asm->GetTempSymbol("debug_ranges", Offset));
 489     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
 490                                                     RE = Ranges.end();
 491          RI != RE; ++RI) {
 492       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 493       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 494     }
 495
 496     // Terminate the range list.
 497     DebugRangeSymbols.push_back(NULL);
 498     DebugRangeSymbols.push_back(NULL);
 499     return ScopeDIE;
 500   }
 501
 502   // Construct the address range for this DIE.
 503   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 504   MCSymbol *Start = getLabelBeforeInsn(RI->first);
 505   MCSymbol *End = getLabelAfterInsn(RI->second);
 506   assert(End && "End label should not be null!");
 507
 508   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
 509   assert(End->isDefined() && "Invalid end label for an inlined scope!");
 510
 511   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
 512   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
 513
 514   return ScopeDIE;
 515 }
 516
 517 // This scope represents inlined body of a function. Construct DIE to
 518 // represent this concrete inlined copy of the function.
 519 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
 520                                           LexicalScope *Scope) {
 521   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 522   assert(Ranges.empty() == false &&
 523          "LexicalScope does not have instruction markers!");
 524
 525   if (!Scope->getScopeNode())
 526     return NULL;
 527   DIScope DS(Scope->getScopeNode());
 528   DISubprogram InlinedSP = getDISubprogram(DS);
 529   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
 530   if (!OriginDIE) {
 531     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
 532     return NULL;
 533   }
 534
 535   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
 536   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin, OriginDIE);
 537
 538   if (Ranges.size() > 1) {
 539     // .debug_range section has not been laid out yet. Emit offset in
 540     // .debug_range as a relocatable label. emitDIE will handle
 541     // emitting it appropriately.
 542     unsigned Offset = DebugRangeSymbols.size();
 543     TheCU->addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges,
 544                            Asm->GetTempSymbol("debug_ranges", Offset));
 545     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
 546                                                     RE = Ranges.end();
 547          RI != RE; ++RI) {
 548       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 549       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 550     }
 551     DebugRangeSymbols.push_back(NULL);
 552     DebugRangeSymbols.push_back(NULL);
 553   } else {
 554     SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 555     MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
 556     MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
 557
 558     if (StartLabel == 0 || EndLabel == 0)
 559       llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
 560
 561     assert(StartLabel->isDefined() &&
 562            "Invalid starting label for an inlined scope!");
 563     assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
 564
 565     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
 566     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
 567   }
 568
 569   InlinedSubprogramDIEs.insert(OriginDIE);
 570
 571   // Add the call site information to the DIE.
 572   DILocation DL(Scope->getInlinedAt());
 573   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, None,
 574                  getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
 575                                      TheCU->getUniqueID()));
 576   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, None, DL.getLineNumber());
 577
 578   // Add name to the name table, we do this here because we're guaranteed
 579   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
 580   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
 581
 582   return ScopeDIE;
 583 }
 584
 585 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
 586                                         SmallVectorImpl<DIE *> &Children) {
 587   DIE *ObjectPointer = NULL;
 588
 589   // Collect arguments for current function.
 590   if (LScopes.isCurrentFunctionScope(Scope))
 591     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 592       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 593         if (DIE *Arg =
 594                 TheCU->constructVariableDIE(*ArgDV, Scope->isAbstractScope())) {
 595           Children.push_back(Arg);
 596           if (ArgDV->isObjectPointer())
 597             ObjectPointer = Arg;
 598         }
 599
 600   // Collect lexical scope children first.
 601   const SmallVectorImpl<DbgVariable *> &Variables =
 602       ScopeVariables.lookup(Scope);
 603   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 604     if (DIE *Variable = TheCU->constructVariableDIE(*Variables[i],
 605                                                     Scope->isAbstractScope())) {
 606       Children.push_back(Variable);
 607       if (Variables[i]->isObjectPointer())
 608         ObjectPointer = Variable;
 609     }
 610   const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
 611   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 612     if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
 613       Children.push_back(Nested);
 614   return ObjectPointer;
 615 }
 616
 617 // Construct a DIE for this scope.
 618 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
 619   if (!Scope || !Scope->getScopeNode())
 620     return NULL;
 621
 622   DIScope DS(Scope->getScopeNode());
 623
 624   SmallVector<DIE *, 8> Children;
 625   DIE *ObjectPointer = NULL;
 626   bool ChildrenCreated = false;
 627
 628   // We try to create the scope DIE first, then the children DIEs. This will
 629   // avoid creating un-used children then removing them later when we find out
 630   // the scope DIE is null.
 631   DIE *ScopeDIE = NULL;
 632   if (Scope->getInlinedAt())
 633     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
 634   else if (DS.isSubprogram()) {
 635     ProcessedSPNodes.insert(DS);
 636     if (Scope->isAbstractScope()) {
 637       ScopeDIE = TheCU->getDIE(DS);
 638       // Note down abstract DIE.
 639       if (ScopeDIE)
 640         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 641     } else
 642       ScopeDIE = updateSubprogramScopeDIE(TheCU, DISubprogram(DS));
 643   } else {
 644     // Early exit when we know the scope DIE is going to be null.
 645     if (isLexicalScopeDIENull(Scope))
 646       return NULL;
 647
 648     // We create children here when we know the scope DIE is not going to be
 649     // null and the children will be added to the scope DIE.
 650     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
 651     ChildrenCreated = true;
 652
 653     // There is no need to emit empty lexical block DIE.
 654     std::pair<ImportedEntityMap::const_iterator,
 655               ImportedEntityMap::const_iterator> Range =
 656         std::equal_range(
 657             ScopesWithImportedEntities.begin(),
 658             ScopesWithImportedEntities.end(),
 659             std::pair<const MDNode *, const MDNode *>(DS, (const MDNode *)0),
 660             less_first());
 661     if (Children.empty() && Range.first == Range.second)
 662       return NULL;
 663     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
 664     assert(ScopeDIE && "Scope DIE should not be null.");
 665     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
 666          ++i)
 667       constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
 668   }
 669
 670   if (!ScopeDIE) {
 671     assert(Children.empty() &&
 672            "We create children only when the scope DIE is not null.");
 673     return NULL;
 674   }
 675   if (!ChildrenCreated)
 676     // We create children when the scope DIE is not null.
 677     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
 678
 679   // Add children
 680   for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
 681                                         E = Children.end();
 682        I != E; ++I)
 683     ScopeDIE->addChild(*I);
 684
 685   if (DS.isSubprogram() && ObjectPointer != NULL)
 686     TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, ObjectPointer);
 687
 688   return ScopeDIE;
 689 }
 690
 691 // Look up the source id with the given directory and source file names.
 692 // If none currently exists, create a new id and insert it in the
 693 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
 694 // as well.
 695 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName, StringRef DirName,
 696                                          unsigned CUID) {
 697   // If we use .loc in assembly, we can't separate .file entries according to
 698   // compile units. Thus all files will belong to the default compile unit.
 699
 700   // FIXME: add a better feature test than hasRawTextSupport. Even better,
 701   // extend .file to support this.
 702   if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
 703     CUID = 0;
 704
 705   // If FE did not provide a file name, then assume stdin.
 706   if (FileName.empty())
 707     return getOrCreateSourceID("<stdin>", StringRef(), CUID);
 708
 709   // TODO: this might not belong here. See if we can factor this better.
 710   if (DirName == CompilationDir)
 711     DirName = "";
 712
 713   // FileIDCUMap stores the current ID for the given compile unit.
 714   unsigned SrcId = FileIDCUMap[CUID] + 1;
 715
 716   // We look up the CUID/file/dir by concatenating them with a zero byte.
 717   SmallString<128> NamePair;
 718   NamePair += utostr(CUID);
 719   NamePair += '\0';
 720   NamePair += DirName;
 721   NamePair += '\0'; // Zero bytes are not allowed in paths.
 722   NamePair += FileName;
 723
 724   StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
 725   if (Ent.getValue() != SrcId)
 726     return Ent.getValue();
 727
 728   FileIDCUMap[CUID] = SrcId;
 729   // Print out a .file directive to specify files for .loc directives.
 730   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
 731
 732   return SrcId;
 733 }
 734
 735 // Create new CompileUnit for the given metadata node with tag
 736 // DW_TAG_compile_unit.
 737 CompileUnit *DwarfDebug::constructCompileUnit(DICompileUnit DIUnit) {
 738   StringRef FN = DIUnit.getFilename();
 739   CompilationDir = DIUnit.getDirectory();
 740
 741   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 742   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++, Die, DIUnit, Asm,
 743                                        this, &InfoHolder);
 744
 745   FileIDCUMap[NewCU->getUniqueID()] = 0;
 746   // Call this to emit a .file directive if it wasn't emitted for the source
 747   // file this CU comes from yet.
 748   getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
 749
 750   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
 751   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 752                  DIUnit.getLanguage());
 753   NewCU->addString(Die, dwarf::DW_AT_name, FN);
 754
 755   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
 756   // into an entity. We're using 0 (or a NULL label) for this. For
 757   // split dwarf it's in the skeleton CU so omit it here.
 758   if (!useSplitDwarf())
 759     NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
 760
 761   // Define start line table label for each Compile Unit.
 762   MCSymbol *LineTableStartSym =
 763       Asm->GetTempSymbol("line_table_start", NewCU->getUniqueID());
 764   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
 765                                                      NewCU->getUniqueID());
 766
 767   // Use a single line table if we are using .loc and generating assembly.
 768   bool UseTheFirstCU =
 769       (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport()) ||
 770       (NewCU->getUniqueID() == 0);
 771
 772   if (!useSplitDwarf()) {
 773     // DW_AT_stmt_list is a offset of line number information for this
 774     // compile unit in debug_line section. For split dwarf this is
 775     // left in the skeleton CU and so not included.
 776     // The line table entries are not always emitted in assembly, so it
 777     // is not okay to use line_table_start here.
 778     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 779       NewCU->addSectionLabel(
 780           Die, dwarf::DW_AT_stmt_list,
 781           UseTheFirstCU ? Asm->GetTempSymbol("section_line")
 782                         : LineTableStartSym);
 783     else if (UseTheFirstCU)
 784       NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
 785     else
 786       NewCU->addSectionDelta(Die, dwarf::DW_AT_stmt_list,
 787                              LineTableStartSym, DwarfLineSectionSym);
 788
 789     // If we're using split dwarf the compilation dir is going to be in the
 790     // skeleton CU and so we don't need to duplicate it here.
 791     if (!CompilationDir.empty())
 792       NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 793
 794     // Flags to let the linker know we have emitted new style pubnames. Only
 795     // emit it here if we don't have a skeleton CU for split dwarf.
 796     if (GenerateGnuPubSections) {
 797       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 798         NewCU->addSectionLabel(
 799             Die, dwarf::DW_AT_GNU_pubnames,
 800             Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
 801       else
 802         NewCU->addSectionDelta(
 803             Die, dwarf::DW_AT_GNU_pubnames,
 804             Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
 805             DwarfGnuPubNamesSectionSym);
 806
 807       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 808         NewCU->addSectionLabel(
 809             Die, dwarf::DW_AT_GNU_pubtypes,
 810             Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
 811       else
 812         NewCU->addSectionDelta(
 813             Die, dwarf::DW_AT_GNU_pubtypes,
 814             Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
 815             DwarfGnuPubTypesSectionSym);
 816     }
 817   }
 818
 819   if (DIUnit.isOptimized())
 820     NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
 821
 822   StringRef Flags = DIUnit.getFlags();
 823   if (!Flags.empty())
 824     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
 825
 826   if (unsigned RVer = DIUnit.getRunTimeVersion())
 827     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 828                    dwarf::DW_FORM_data1, RVer);
 829
 830   if (!FirstCU)
 831     FirstCU = NewCU;
 832
 833   InfoHolder.addUnit(NewCU);
 834
 835   CUMap.insert(std::make_pair(DIUnit, NewCU));
 836   CUDieMap.insert(std::make_pair(Die, NewCU));
 837   return NewCU;
 838 }
 839
 840 // Construct subprogram DIE.
 841 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU, const MDNode *N) {
 842   // FIXME: We should only call this routine once, however, during LTO if a
 843   // program is defined in multiple CUs we could end up calling it out of
 844   // beginModule as we walk the CUs.
 845
 846   CompileUnit *&CURef = SPMap[N];
 847   if (CURef)
 848     return;
 849   CURef = TheCU;
 850
 851   DISubprogram SP(N);
 852   if (!SP.isDefinition())
 853     // This is a method declaration which will be handled while constructing
 854     // class type.
 855     return;
 856
 857   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 858
 859   // Expose as a global name.
 860   TheCU->addGlobalName(SP.getName(), SubprogramDie, resolve(SP.getContext()));
 861 }
 862
 863 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 864                                             const MDNode *N) {
 865   DIImportedEntity Module(N);
 866   if (!Module.Verify())
 867     return;
 868   if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
 869     constructImportedEntityDIE(TheCU, Module, D);
 870 }
 871
 872 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
 873                                             DIE *Context) {
 874   DIImportedEntity Module(N);
 875   if (!Module.Verify())
 876     return;
 877   return constructImportedEntityDIE(TheCU, Module, Context);
 878 }
 879
 880 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 881                                             const DIImportedEntity &Module,
 882                                             DIE *Context) {
 883   assert(Module.Verify() &&
 884          "Use one of the MDNode * overloads to handle invalid metadata");
 885   assert(Context && "Should always have a context for an imported_module");
 886   DIE *IMDie = new DIE(Module.getTag());
 887   TheCU->insertDIE(Module, IMDie);
 888   DIE *EntityDie;
 889   DIDescriptor Entity = Module.getEntity();
 890   if (Entity.isNameSpace())
 891     EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
 892   else if (Entity.isSubprogram())
 893     EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
 894   else if (Entity.isType())
 895     EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
 896   else
 897     EntityDie = TheCU->getDIE(Entity);
 898   unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
 899                                         Module.getContext().getDirectory(),
 900                                         TheCU->getUniqueID());
 901   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, None, FileID);
 902   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, None, Module.getLineNumber());
 903   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, EntityDie);
 904   StringRef Name = Module.getName();
 905   if (!Name.empty())
 906     TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
 907   Context->addChild(IMDie);
 908 }
 909
 910 // Emit all Dwarf sections that should come prior to the content. Create
 911 // global DIEs and emit initial debug info sections. This is invoked by
 912 // the target AsmPrinter.
 913 void DwarfDebug::beginModule() {
 914   if (DisableDebugInfoPrinting)
 915     return;
 916
 917   const Module *M = MMI->getModule();
 918
 919   // If module has named metadata anchors then use them, otherwise scan the
 920   // module using debug info finder to collect debug info.
 921   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 922   if (!CU_Nodes)
 923     return;
 924   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
 925
 926   // Emit initial sections so we can reference labels later.
 927   emitSectionLabels();
 928
 929   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 930     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 931     CompileUnit *CU = constructCompileUnit(CUNode);
 932     DIArray ImportedEntities = CUNode.getImportedEntities();
 933     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 934       ScopesWithImportedEntities.push_back(std::make_pair(
 935           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
 936           ImportedEntities.getElement(i)));
 937     std::sort(ScopesWithImportedEntities.begin(),
 938               ScopesWithImportedEntities.end(), less_first());
 939     DIArray GVs = CUNode.getGlobalVariables();
 940     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 941       CU->createGlobalVariableDIE(DIGlobalVariable(GVs.getElement(i)));
 942     DIArray SPs = CUNode.getSubprograms();
 943     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 944       constructSubprogramDIE(CU, SPs.getElement(i));
 945     DIArray EnumTypes = CUNode.getEnumTypes();
 946     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 947       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 948     DIArray RetainedTypes = CUNode.getRetainedTypes();
 949     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 950       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 951     // Emit imported_modules last so that the relevant context is already
 952     // available.
 953     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 954       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
 955   }
 956
 957   // Tell MMI that we have debug info.
 958   MMI->setDebugInfoAvailability(true);
 959
 960   // Prime section data.
 961   SectionMap[Asm->getObjFileLowering().getTextSection()];
 962 }
 963
 964 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 965 void DwarfDebug::computeInlinedDIEs() {
 966   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 967   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 968                                        AE = InlinedSubprogramDIEs.end();
 969        AI != AE; ++AI) {
 970     DIE *ISP = *AI;
 971     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
 972   }
 973   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 974                                                  AE = AbstractSPDies.end();
 975        AI != AE; ++AI) {
 976     DIE *ISP = AI->second;
 977     if (InlinedSubprogramDIEs.count(ISP))
 978       continue;
 979     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
 980   }
 981 }
 982
 983 // Collect info for variables that were optimized out.
 984 void DwarfDebug::collectDeadVariables() {
 985   const Module *M = MMI->getModule();
 986
 987   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 988     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 989       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 990       DIArray Subprograms = TheCU.getSubprograms();
 991       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 992         DISubprogram SP(Subprograms.getElement(i));
 993         if (ProcessedSPNodes.count(SP) != 0)
 994           continue;
 995         if (!SP.isSubprogram())
 996           continue;
 997         if (!SP.isDefinition())
 998           continue;
 999         DIArray Variables = SP.getVariables();
1000         if (Variables.getNumElements() == 0)
1001           continue;
1002
1003         // Construct subprogram DIE and add variables DIEs.
1004         CompileUnit *SPCU = static_cast<CompileUnit *>(CUMap.lookup(TheCU));
1005         assert(SPCU && "Unable to find Compile Unit!");
1006         // FIXME: See the comment in constructSubprogramDIE about duplicate
1007         // subprogram DIEs.
1008         constructSubprogramDIE(SPCU, SP);
1009         DIE *SPDIE = SPCU->getDIE(SP);
1010         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
1011           DIVariable DV(Variables.getElement(vi));
1012           if (!DV.isVariable())
1013             continue;
1014           DbgVariable NewVar(DV, NULL, this);
1015           if (DIE *VariableDIE = SPCU->constructVariableDIE(NewVar, false))
1016             SPDIE->addChild(VariableDIE);
1017         }
1018       }
1019     }
1020   }
1021 }
1022
1023 // Type Signature [7.27] and ODR Hash code.
1024
1025 /// \brief Grabs the string in whichever attribute is passed in and returns
1026 /// a reference to it. Returns "" if the attribute doesn't exist.
1027 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1028   DIEValue *V = Die->findAttribute(Attr);
1029
1030   if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1031     return S->getString();
1032
1033   return StringRef("");
1034 }
1035
1036 /// Return true if the current DIE is contained within an anonymous namespace.
1037 static bool isContainedInAnonNamespace(DIE *Die) {
1038   DIE *Parent = Die->getParent();
1039
1040   while (Parent) {
1041     if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1042         getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1043       return true;
1044     Parent = Parent->getParent();
1045   }
1046
1047   return false;
1048 }
1049
1050 /// Test if the current CU language is C++ and that we have
1051 /// a named type that is not contained in an anonymous namespace.
1052 static bool shouldAddODRHash(TypeUnit *CU, DIE *Die) {
1053   return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1054          getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1055          !isContainedInAnonNamespace(Die);
1056 }
1057
1058 void DwarfDebug::finalizeModuleInfo() {
1059   // Collect info for variables that were optimized out.
1060   collectDeadVariables();
1061
1062   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1063   computeInlinedDIEs();
1064
1065   // Handle anything that needs to be done on a per-cu basis.
1066   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
1067                                                E = getUnits().end();
1068        I != E; ++I) {
1069     Unit *TheCU = *I;
1070     // Emit DW_AT_containing_type attribute to connect types with their
1071     // vtable holding type.
1072     TheCU->constructContainingTypeDIEs();
1073
1074     // If we're splitting the dwarf out now that we've got the entire
1075     // CU then construct a skeleton CU based upon it.
1076     if (useSplitDwarf() &&
1077         TheCU->getCUDie()->getTag() == dwarf::DW_TAG_compile_unit) {
1078       uint64_t ID = 0;
1079       if (GenerateCUHash) {
1080         DIEHash CUHash;
1081         ID = CUHash.computeCUSignature(*TheCU->getCUDie());
1082       }
1083       // This should be a unique identifier when we want to build .dwp files.
1084       TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1085                      dwarf::DW_FORM_data8, ID);
1086       // Now construct the skeleton CU associated.
1087       CompileUnit *SkCU =
1088           constructSkeletonCU(static_cast<CompileUnit *>(TheCU));
1089       // This should be a unique identifier when we want to build .dwp files.
1090       SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1091                     dwarf::DW_FORM_data8, ID);
1092     }
1093   }
1094
1095   // Compute DIE offsets and sizes.
1096   InfoHolder.computeSizeAndOffsets();
1097   if (useSplitDwarf())
1098     SkeletonHolder.computeSizeAndOffsets();
1099 }
1100
1101 void DwarfDebug::endSections() {
1102   // Filter labels by section.
1103   for (size_t n = 0; n < ArangeLabels.size(); n++) {
1104     const SymbolCU &SCU = ArangeLabels[n];
1105     if (SCU.Sym->isInSection()) {
1106       // Make a note of this symbol and it's section.
1107       const MCSection *Section = &SCU.Sym->getSection();
1108       if (!Section->getKind().isMetadata())
1109         SectionMap[Section].push_back(SCU);
1110     } else {
1111       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1112       // appear in the output. This sucks as we rely on sections to build
1113       // arange spans. We can do it without, but it's icky.
1114       SectionMap[NULL].push_back(SCU);
1115     }
1116   }
1117
1118   // Build a list of sections used.
1119   std::vector<const MCSection *> Sections;
1120   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1121        it++) {
1122     const MCSection *Section = it->first;
1123     Sections.push_back(Section);
1124   }
1125
1126   // Sort the sections into order.
1127   // This is only done to ensure consistent output order across different runs.
1128   std::sort(Sections.begin(), Sections.end(), SectionSort);
1129
1130   // Add terminating symbols for each section.
1131   for (unsigned ID = 0; ID < Sections.size(); ID++) {
1132     const MCSection *Section = Sections[ID];
1133     MCSymbol *Sym = NULL;
1134
1135     if (Section) {
1136       // We can't call MCSection::getLabelEndName, as it's only safe to do so
1137       // if we know the section name up-front. For user-created sections, the
1138       // resulting
1139       // label may not be valid to use as a label. (section names can use a
1140       // greater
1141       // set of characters on some systems)
1142       Sym = Asm->GetTempSymbol("debug_end", ID);
1143       Asm->OutStreamer.SwitchSection(Section);
1144       Asm->OutStreamer.EmitLabel(Sym);
1145     }
1146
1147     // Insert a final terminator.
1148     SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1149   }
1150 }
1151
1152 // Emit all Dwarf sections that should come after the content.
1153 void DwarfDebug::endModule() {
1154
1155   if (!FirstCU)
1156     return;
1157
1158   // End any existing sections.
1159   // TODO: Does this need to happen?
1160   endSections();
1161
1162   // Finalize the debug info for the module.
1163   finalizeModuleInfo();
1164
1165   emitDebugStr();
1166
1167   // Emit all the DIEs into a debug info section.
1168   emitDebugInfo();
1169
1170   // Corresponding abbreviations into a abbrev section.
1171   emitAbbreviations();
1172
1173   // Emit info into a debug loc section.
1174   emitDebugLoc();
1175
1176   // Emit info into a debug aranges section.
1177   emitDebugARanges();
1178
1179   // Emit info into a debug ranges section.
1180   emitDebugRanges();
1181
1182   // Emit info into a debug macinfo section.
1183   emitDebugMacInfo();
1184
1185   if (useSplitDwarf()) {
1186     emitDebugStrDWO();
1187     emitDebugInfoDWO();
1188     emitDebugAbbrevDWO();
1189     // Emit DWO addresses.
1190     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1191   }
1192
1193   // Emit info into the dwarf accelerator table sections.
1194   if (useDwarfAccelTables()) {
1195     emitAccelNames();
1196     emitAccelObjC();
1197     emitAccelNamespaces();
1198     emitAccelTypes();
1199   }
1200
1201   // Emit the pubnames and pubtypes sections if requested.
1202   if (HasDwarfPubSections) {
1203     emitDebugPubNames(GenerateGnuPubSections);
1204     emitDebugPubTypes(GenerateGnuPubSections);
1205   }
1206
1207   // clean up.
1208   SPMap.clear();
1209
1210   // Reset these for the next Module if we have one.
1211   FirstCU = NULL;
1212 }
1213
1214 // Find abstract variable, if any, associated with Var.
1215 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1216                                               DebugLoc ScopeLoc) {
1217   LLVMContext &Ctx = DV->getContext();
1218   // More then one inlined variable corresponds to one abstract variable.
1219   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1220   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1221   if (AbsDbgVariable)
1222     return AbsDbgVariable;
1223
1224   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1225   if (!Scope)
1226     return NULL;
1227
1228   AbsDbgVariable = new DbgVariable(Var, NULL, this);
1229   addScopeVariable(Scope, AbsDbgVariable);
1230   AbstractVariables[Var] = AbsDbgVariable;
1231   return AbsDbgVariable;
1232 }
1233
1234 // If Var is a current function argument then add it to CurrentFnArguments list.
1235 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1236                                       DbgVariable *Var, LexicalScope *Scope) {
1237   if (!LScopes.isCurrentFunctionScope(Scope))
1238     return false;
1239   DIVariable DV = Var->getVariable();
1240   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1241     return false;
1242   unsigned ArgNo = DV.getArgNumber();
1243   if (ArgNo == 0)
1244     return false;
1245
1246   size_t Size = CurrentFnArguments.size();
1247   if (Size == 0)
1248     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1249   // llvm::Function argument size is not good indicator of how many
1250   // arguments does the function have at source level.
1251   if (ArgNo > Size)
1252     CurrentFnArguments.resize(ArgNo * 2);
1253   CurrentFnArguments[ArgNo - 1] = Var;
1254   return true;
1255 }
1256
1257 // Collect variable information from side table maintained by MMI.
1258 void DwarfDebug::collectVariableInfoFromMMITable(
1259     const MachineFunction *MF, SmallPtrSet<const MDNode *, 16> &Processed) {
1260   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1261   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1262                                                          VE = VMap.end();
1263        VI != VE; ++VI) {
1264     const MDNode *Var = VI->first;
1265     if (!Var)
1266       continue;
1267     Processed.insert(Var);
1268     DIVariable DV(Var);
1269     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1270
1271     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1272
1273     // If variable scope is not found then skip this variable.
1274     if (Scope == 0)
1275       continue;
1276
1277     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1278     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1279     RegVar->setFrameIndex(VP.first);
1280     if (!addCurrentFnArgument(MF, RegVar, Scope))
1281       addScopeVariable(Scope, RegVar);
1282     if (AbsDbgVariable)
1283       AbsDbgVariable->setFrameIndex(VP.first);
1284   }
1285 }
1286
1287 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1288 // defined reg.
1289 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1290   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1291   return MI->getNumOperands() == 3 && MI->getOperand(0).isReg() &&
1292          MI->getOperand(0).getReg() &&
1293          (MI->getOperand(1).isImm() ||
1294           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1295 }
1296
1297 // Get .debug_loc entry for the instruction range starting at MI.
1298 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1299                                          const MCSymbol *FLabel,
1300                                          const MCSymbol *SLabel,
1301                                          const MachineInstr *MI) {
1302   const MDNode *Var = MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1303
1304   assert(MI->getNumOperands() == 3);
1305   if (MI->getOperand(0).isReg()) {
1306     MachineLocation MLoc;
1307     // If the second operand is an immediate, this is a
1308     // register-indirect address.
1309     if (!MI->getOperand(1).isImm())
1310       MLoc.set(MI->getOperand(0).getReg());
1311     else
1312       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1313     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1314   }
1315   if (MI->getOperand(0).isImm())
1316     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1317   if (MI->getOperand(0).isFPImm())
1318     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1319   if (MI->getOperand(0).isCImm())
1320     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1321
1322   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1323 }
1324
1325 // Find variables for each lexical scope.
1326 void
1327 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1328                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1329
1330   // Grab the variable info that was squirreled away in the MMI side-table.
1331   collectVariableInfoFromMMITable(MF, Processed);
1332
1333   for (SmallVectorImpl<const MDNode *>::const_iterator
1334            UVI = UserVariables.begin(),
1335            UVE = UserVariables.end();
1336        UVI != UVE; ++UVI) {
1337     const MDNode *Var = *UVI;
1338     if (Processed.count(Var))
1339       continue;
1340
1341     // History contains relevant DBG_VALUE instructions for Var and instructions
1342     // clobbering it.
1343     SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1344     if (History.empty())
1345       continue;
1346     const MachineInstr *MInsn = History.front();
1347
1348     DIVariable DV(Var);
1349     LexicalScope *Scope = NULL;
1350     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1351         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1352       Scope = LScopes.getCurrentFunctionScope();
1353     else if (MDNode *IA = DV.getInlinedAt())
1354       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1355     else
1356       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1357     // If variable scope is not found then skip this variable.
1358     if (!Scope)
1359       continue;
1360
1361     Processed.insert(DV);
1362     assert(MInsn->isDebugValue() && "History must begin with debug value");
1363     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1364     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1365     if (!addCurrentFnArgument(MF, RegVar, Scope))
1366       addScopeVariable(Scope, RegVar);
1367     if (AbsVar)
1368       AbsVar->setMInsn(MInsn);
1369
1370     // Simplify ranges that are fully coalesced.
1371     if (History.size() <= 1 ||
1372         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
1373       RegVar->setMInsn(MInsn);
1374       continue;
1375     }
1376
1377     // Handle multiple DBG_VALUE instructions describing one variable.
1378     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1379
1380     for (SmallVectorImpl<const MachineInstr *>::const_iterator
1381              HI = History.begin(),
1382              HE = History.end();
1383          HI != HE; ++HI) {
1384       const MachineInstr *Begin = *HI;
1385       assert(Begin->isDebugValue() && "Invalid History entry");
1386
1387       // Check if DBG_VALUE is truncating a range.
1388       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg() &&
1389           !Begin->getOperand(0).getReg())
1390         continue;
1391
1392       // Compute the range for a register location.
1393       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1394       const MCSymbol *SLabel = 0;
1395
1396       if (HI + 1 == HE)
1397         // If Begin is the last instruction in History then its value is valid
1398         // until the end of the function.
1399         SLabel = FunctionEndSym;
1400       else {
1401         const MachineInstr *End = HI[1];
1402         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1403                      << "\t" << *Begin << "\t" << *End << "\n");
1404         if (End->isDebugValue())
1405           SLabel = getLabelBeforeInsn(End);
1406         else {
1407           // End is a normal instruction clobbering the range.
1408           SLabel = getLabelAfterInsn(End);
1409           assert(SLabel && "Forgot label after clobber instruction");
1410           ++HI;
1411         }
1412       }
1413
1414       // The value is valid until the next DBG_VALUE or clobber.
1415       DotDebugLocEntries.push_back(
1416           getDebugLocEntry(Asm, FLabel, SLabel, Begin));
1417     }
1418     DotDebugLocEntries.push_back(DotDebugLocEntry());
1419   }
1420
1421   // Collect info for variables that were optimized out.
1422   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1423   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1424   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1425     DIVariable DV(Variables.getElement(i));
1426     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1427       continue;
1428     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1429       addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1430   }
1431 }
1432
1433 // Return Label preceding the instruction.
1434 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1435   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1436   assert(Label && "Didn't insert label before instruction");
1437   return Label;
1438 }
1439
1440 // Return Label immediately following the instruction.
1441 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1442   return LabelsAfterInsn.lookup(MI);
1443 }
1444
1445 // Process beginning of an instruction.
1446 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1447   // Check if source location changes, but ignore DBG_VALUE locations.
1448   if (!MI->isDebugValue()) {
1449     DebugLoc DL = MI->getDebugLoc();
1450     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1451       unsigned Flags = 0;
1452       PrevInstLoc = DL;
1453       if (DL == PrologEndLoc) {
1454         Flags |= DWARF2_FLAG_PROLOGUE_END;
1455         PrologEndLoc = DebugLoc();
1456       }
1457       if (PrologEndLoc.isUnknown())
1458         Flags |= DWARF2_FLAG_IS_STMT;
1459
1460       if (!DL.isUnknown()) {
1461         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1462         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1463       } else
1464         recordSourceLine(0, 0, 0, 0);
1465     }
1466   }
1467
1468   // Insert labels where requested.
1469   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1470       LabelsBeforeInsn.find(MI);
1471
1472   // No label needed.
1473   if (I == LabelsBeforeInsn.end())
1474     return;
1475
1476   // Label already assigned.
1477   if (I->second)
1478     return;
1479
1480   if (!PrevLabel) {
1481     PrevLabel = MMI->getContext().CreateTempSymbol();
1482     Asm->OutStreamer.EmitLabel(PrevLabel);
1483   }
1484   I->second = PrevLabel;
1485 }
1486
1487 // Process end of an instruction.
1488 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1489   // Don't create a new label after DBG_VALUE instructions.
1490   // They don't generate code.
1491   if (!MI->isDebugValue())
1492     PrevLabel = 0;
1493
1494   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
1495       LabelsAfterInsn.find(MI);
1496
1497   // No label needed.
1498   if (I == LabelsAfterInsn.end())
1499     return;
1500
1501   // Label already assigned.
1502   if (I->second)
1503     return;
1504
1505   // We need a label after this instruction.
1506   if (!PrevLabel) {
1507     PrevLabel = MMI->getContext().CreateTempSymbol();
1508     Asm->OutStreamer.EmitLabel(PrevLabel);
1509   }
1510   I->second = PrevLabel;
1511 }
1512
1513 // Each LexicalScope has first instruction and last instruction to mark
1514 // beginning and end of a scope respectively. Create an inverse map that list
1515 // scopes starts (and ends) with an instruction. One instruction may start (or
1516 // end) multiple scopes. Ignore scopes that are not reachable.
1517 void DwarfDebug::identifyScopeMarkers() {
1518   SmallVector<LexicalScope *, 4> WorkList;
1519   WorkList.push_back(LScopes.getCurrentFunctionScope());
1520   while (!WorkList.empty()) {
1521     LexicalScope *S = WorkList.pop_back_val();
1522
1523     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1524     if (!Children.empty())
1525       for (SmallVectorImpl<LexicalScope *>::const_iterator
1526                SI = Children.begin(),
1527                SE = Children.end();
1528            SI != SE; ++SI)
1529         WorkList.push_back(*SI);
1530
1531     if (S->isAbstractScope())
1532       continue;
1533
1534     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1535     if (Ranges.empty())
1536       continue;
1537     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1538                                                     RE = Ranges.end();
1539          RI != RE; ++RI) {
1540       assert(RI->first && "InsnRange does not have first instruction!");
1541       assert(RI->second && "InsnRange does not have second instruction!");
1542       requestLabelBeforeInsn(RI->first);
1543       requestLabelAfterInsn(RI->second);
1544     }
1545   }
1546 }
1547
1548 // Get MDNode for DebugLoc's scope.
1549 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1550   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1551     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1552   return DL.getScope(Ctx);
1553 }
1554
1555 // Walk up the scope chain of given debug loc and find line number info
1556 // for the function.
1557 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1558   const MDNode *Scope = getScopeNode(DL, Ctx);
1559   DISubprogram SP = getDISubprogram(Scope);
1560   if (SP.isSubprogram()) {
1561     // Check for number of operands since the compatibility is
1562     // cheap here.
1563     if (SP->getNumOperands() > 19)
1564       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1565     else
1566       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1567   }
1568
1569   return DebugLoc();
1570 }
1571
1572 // Gather pre-function debug information.  Assumes being called immediately
1573 // after the function entry point has been emitted.
1574 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1575
1576   // If there's no debug info for the function we're not going to do anything.
1577   if (!MMI->hasDebugInfo())
1578     return;
1579
1580   // Grab the lexical scopes for the function, if we don't have any of those
1581   // then we're not going to be able to do anything.
1582   LScopes.initialize(*MF);
1583   if (LScopes.empty())
1584     return;
1585
1586   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1587
1588   // Make sure that each lexical scope will have a begin/end label.
1589   identifyScopeMarkers();
1590
1591   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1592   // belongs to so that we add to the correct per-cu line table in the
1593   // non-asm case.
1594   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1595   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1596   assert(TheCU && "Unable to find compile unit!");
1597   if (Asm->TM.hasMCUseLoc() && Asm->OutStreamer.hasRawTextSupport())
1598     // Use a single line table if we are using .loc and generating assembly.
1599     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1600   else
1601     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1602
1603   // Emit a label for the function so that we have a beginning address.
1604   FunctionBeginSym = Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber());
1605   // Assumes in correct section after the entry point.
1606   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1607
1608   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1609   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1610   std::vector<const MDNode *> LiveUserVar(TRI->getNumRegs());
1611
1612   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end(); I != E;
1613        ++I) {
1614     bool AtBlockEntry = true;
1615     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1616          II != IE; ++II) {
1617       const MachineInstr *MI = II;
1618
1619       if (MI->isDebugValue()) {
1620         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1621
1622         // Keep track of user variables.
1623         const MDNode *Var =
1624             MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1625
1626         // Variable is in a register, we need to check for clobbers.
1627         if (isDbgValueInDefinedReg(MI))
1628           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1629
1630         // Check the history of this variable.
1631         SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
1632         if (History.empty()) {
1633           UserVariables.push_back(Var);
1634           // The first mention of a function argument gets the FunctionBeginSym
1635           // label, so arguments are visible when breaking at function entry.
1636           DIVariable DV(Var);
1637           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1638               getDISubprogram(DV.getContext()).describes(MF->getFunction()))
1639             LabelsBeforeInsn[MI] = FunctionBeginSym;
1640         } else {
1641           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1642           const MachineInstr *Prev = History.back();
1643           if (Prev->isDebugValue()) {
1644             // Coalesce identical entries at the end of History.
1645             if (History.size() >= 2 &&
1646                 Prev->isIdenticalTo(History[History.size() - 2])) {
1647               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1648                            << "\t" << *Prev << "\t"
1649                            << *History[History.size() - 2] << "\n");
1650               History.pop_back();
1651             }
1652
1653             // Terminate old register assignments that don't reach MI;
1654             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1655             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1656                 isDbgValueInDefinedReg(Prev)) {
1657               // Previous register assignment needs to terminate at the end of
1658               // its basic block.
1659               MachineBasicBlock::const_iterator LastMI =
1660                   PrevMBB->getLastNonDebugInstr();
1661               if (LastMI == PrevMBB->end()) {
1662                 // Drop DBG_VALUE for empty range.
1663                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1664                              << "\t" << *Prev << "\n");
1665                 History.pop_back();
1666               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1667                 // Terminate after LastMI.
1668                 History.push_back(LastMI);
1669             }
1670           }
1671         }
1672         History.push_back(MI);
1673       } else {
1674         // Not a DBG_VALUE instruction.
1675         if (!MI->isLabel())
1676           AtBlockEntry = false;
1677
1678         // First known non-DBG_VALUE and non-frame setup location marks
1679         // the beginning of the function body.
1680         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1681             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1682           PrologEndLoc = MI->getDebugLoc();
1683
1684         // Check if the instruction clobbers any registers with debug vars.
1685         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1686                                               MOE = MI->operands_end();
1687              MOI != MOE; ++MOI) {
1688           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1689             continue;
1690           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true); AI.isValid();
1691                ++AI) {
1692             unsigned Reg = *AI;
1693             const MDNode *Var = LiveUserVar[Reg];
1694             if (!Var)
1695               continue;
1696             // Reg is now clobbered.
1697             LiveUserVar[Reg] = 0;
1698
1699             // Was MD last defined by a DBG_VALUE referring to Reg?
1700             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1701             if (HistI == DbgValues.end())
1702               continue;
1703             SmallVectorImpl<const MachineInstr *> &History = HistI->second;
1704             if (History.empty())
1705               continue;
1706             const MachineInstr *Prev = History.back();
1707             // Sanity-check: Register assignments are terminated at the end of
1708             // their block.
1709             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1710               continue;
1711             // Is the variable still in Reg?
1712             if (!isDbgValueInDefinedReg(Prev) ||
1713                 Prev->getOperand(0).getReg() != Reg)
1714               continue;
1715             // Var is clobbered. Make sure the next instruction gets a label.
1716             History.push_back(MI);
1717           }
1718         }
1719       }
1720     }
1721   }
1722
1723   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1724        I != E; ++I) {
1725     SmallVectorImpl<const MachineInstr *> &History = I->second;
1726     if (History.empty())
1727       continue;
1728
1729     // Make sure the final register assignments are terminated.
1730     const MachineInstr *Prev = History.back();
1731     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1732       const MachineBasicBlock *PrevMBB = Prev->getParent();
1733       MachineBasicBlock::const_iterator LastMI =
1734           PrevMBB->getLastNonDebugInstr();
1735       if (LastMI == PrevMBB->end())
1736         // Drop DBG_VALUE for empty range.
1737         History.pop_back();
1738       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1739         // Terminate after LastMI.
1740         History.push_back(LastMI);
1741       }
1742     }
1743     // Request labels for the full history.
1744     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1745       const MachineInstr *MI = History[i];
1746       if (MI->isDebugValue())
1747         requestLabelBeforeInsn(MI);
1748       else
1749         requestLabelAfterInsn(MI);
1750     }
1751   }
1752
1753   PrevInstLoc = DebugLoc();
1754   PrevLabel = FunctionBeginSym;
1755
1756   // Record beginning of function.
1757   if (!PrologEndLoc.isUnknown()) {
1758     DebugLoc FnStartDL =
1759         getFnDebugLoc(PrologEndLoc, MF->getFunction()->getContext());
1760     recordSourceLine(
1761         FnStartDL.getLine(), FnStartDL.getCol(),
1762         FnStartDL.getScope(MF->getFunction()->getContext()),
1763         // We'd like to list the prologue as "not statements" but GDB behaves
1764         // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1765         DWARF2_FLAG_IS_STMT);
1766   }
1767 }
1768
1769 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1770   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1771   DIVariable DV = Var->getVariable();
1772   // Variables with positive arg numbers are parameters.
1773   if (unsigned ArgNum = DV.getArgNumber()) {
1774     // Keep all parameters in order at the start of the variable list to ensure
1775     // function types are correct (no out-of-order parameters)
1776     //
1777     // This could be improved by only doing it for optimized builds (unoptimized
1778     // builds have the right order to begin with), searching from the back (this
1779     // would catch the unoptimized case quickly), or doing a binary search
1780     // rather than linear search.
1781     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1782     while (I != Vars.end()) {
1783       unsigned CurNum = (*I)->getVariable().getArgNumber();
1784       // A local (non-parameter) variable has been found, insert immediately
1785       // before it.
1786       if (CurNum == 0)
1787         break;
1788       // A later indexed parameter has been found, insert immediately before it.
1789       if (CurNum > ArgNum)
1790         break;
1791       ++I;
1792     }
1793     Vars.insert(I, Var);
1794     return;
1795   }
1796
1797   Vars.push_back(Var);
1798 }
1799
1800 // Gather and emit post-function debug information.
1801 void DwarfDebug::endFunction(const MachineFunction *MF) {
1802   if (!MMI->hasDebugInfo() || LScopes.empty())
1803     return;
1804
1805   // Define end label for subprogram.
1806   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
1807   // Assumes in correct section after the entry point.
1808   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1809   // Set DwarfCompileUnitID in MCContext to default value.
1810   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1811
1812   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1813   collectVariableInfo(MF, ProcessedVars);
1814
1815   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1816   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1817   assert(TheCU && "Unable to find compile unit!");
1818
1819   // Construct abstract scopes.
1820   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1821   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1822     LexicalScope *AScope = AList[i];
1823     DISubprogram SP(AScope->getScopeNode());
1824     if (SP.isSubprogram()) {
1825       // Collect info for variables that were optimized out.
1826       DIArray Variables = SP.getVariables();
1827       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1828         DIVariable DV(Variables.getElement(i));
1829         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1830           continue;
1831         // Check that DbgVariable for DV wasn't created earlier, when
1832         // findAbstractVariable() was called for inlined instance of DV.
1833         LLVMContext &Ctx = DV->getContext();
1834         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1835         if (AbstractVariables.lookup(CleanDV))
1836           continue;
1837         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1838           addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1839       }
1840     }
1841     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1842       constructScopeDIE(TheCU, AScope);
1843   }
1844
1845   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1846
1847   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1848     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1849
1850   // Clear debug info
1851   for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
1852                                    E = ScopeVariables.end();
1853        I != E; ++I)
1854     DeleteContainerPointers(I->second);
1855   ScopeVariables.clear();
1856   DeleteContainerPointers(CurrentFnArguments);
1857   UserVariables.clear();
1858   DbgValues.clear();
1859   AbstractVariables.clear();
1860   LabelsBeforeInsn.clear();
1861   LabelsAfterInsn.clear();
1862   PrevLabel = NULL;
1863 }
1864
1865 // Register a source line with debug info. Returns the  unique label that was
1866 // emitted and which provides correspondence to the source line list.
1867 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1868                                   unsigned Flags) {
1869   StringRef Fn;
1870   StringRef Dir;
1871   unsigned Src = 1;
1872   if (S) {
1873     DIDescriptor Scope(S);
1874
1875     if (Scope.isCompileUnit()) {
1876       DICompileUnit CU(S);
1877       Fn = CU.getFilename();
1878       Dir = CU.getDirectory();
1879     } else if (Scope.isFile()) {
1880       DIFile F(S);
1881       Fn = F.getFilename();
1882       Dir = F.getDirectory();
1883     } else if (Scope.isSubprogram()) {
1884       DISubprogram SP(S);
1885       Fn = SP.getFilename();
1886       Dir = SP.getDirectory();
1887     } else if (Scope.isLexicalBlockFile()) {
1888       DILexicalBlockFile DBF(S);
1889       Fn = DBF.getFilename();
1890       Dir = DBF.getDirectory();
1891     } else if (Scope.isLexicalBlock()) {
1892       DILexicalBlock DB(S);
1893       Fn = DB.getFilename();
1894       Dir = DB.getDirectory();
1895     } else
1896       llvm_unreachable("Unexpected scope info");
1897
1898     Src = getOrCreateSourceID(
1899         Fn, Dir, Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1900   }
1901   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1902 }
1903
1904 //===----------------------------------------------------------------------===//
1905 // Emit Methods
1906 //===----------------------------------------------------------------------===//
1907
1908 // Compute the size and offset of a DIE. The offset is relative to start of the
1909 // CU. It returns the offset after laying out the DIE.
1910 unsigned DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1911   // Get the children.
1912   const std::vector<DIE *> &Children = Die->getChildren();
1913
1914   // Record the abbreviation.
1915   assignAbbrevNumber(Die->getAbbrev());
1916
1917   // Get the abbreviation for this DIE.
1918   unsigned AbbrevNumber = Die->getAbbrevNumber();
1919   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1920
1921   // Set DIE offset
1922   Die->setOffset(Offset);
1923
1924   // Start the size with the size of abbreviation code.
1925   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1926
1927   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
1928   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1929
1930   // Size the DIE attribute values.
1931   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1932     // Size attribute value.
1933     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1934
1935   // Size the DIE children if any.
1936   if (!Children.empty()) {
1937     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1938            "Children flag not set");
1939
1940     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1941       Offset = computeSizeAndOffset(Children[j], Offset);
1942
1943     // End of children marker.
1944     Offset += sizeof(int8_t);
1945   }
1946
1947   Die->setSize(Offset - Die->getOffset());
1948   return Offset;
1949 }
1950
1951 // Compute the size and offset for each DIE.
1952 void DwarfUnits::computeSizeAndOffsets() {
1953   // Offset from the first CU in the debug info section is 0 initially.
1954   unsigned SecOffset = 0;
1955
1956   // Iterate over each compile unit and set the size and offsets for each
1957   // DIE within each compile unit. All offsets are CU relative.
1958   for (SmallVectorImpl<Unit *>::const_iterator I = CUs.begin(), E = CUs.end();
1959        I != E; ++I) {
1960     (*I)->setDebugInfoOffset(SecOffset);
1961
1962     // CU-relative offset is reset to 0 here.
1963     unsigned Offset = sizeof(int32_t) +      // Length of Unit Info
1964                       (*I)->getHeaderSize(); // Unit-specific headers
1965
1966     // EndOffset here is CU-relative, after laying out
1967     // all of the CU DIE.
1968     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1969     SecOffset += EndOffset;
1970   }
1971 }
1972
1973 // Emit initial Dwarf sections with a label at the start of each one.
1974 void DwarfDebug::emitSectionLabels() {
1975   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1976
1977   // Dwarf sections base addresses.
1978   DwarfInfoSectionSym =
1979       emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1980   DwarfAbbrevSectionSym =
1981       emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1982   if (useSplitDwarf())
1983     DwarfAbbrevDWOSectionSym = emitSectionSym(
1984         Asm, TLOF.getDwarfAbbrevDWOSection(), "section_abbrev_dwo");
1985   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1986
1987   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1988     emitSectionSym(Asm, MacroInfo);
1989
1990   DwarfLineSectionSym =
1991       emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1992   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1993   if (GenerateGnuPubSections) {
1994     DwarfGnuPubNamesSectionSym =
1995         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1996     DwarfGnuPubTypesSectionSym =
1997         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1998   } else if (HasDwarfPubSections) {
1999     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2000     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2001   }
2002
2003   DwarfStrSectionSym =
2004       emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2005   if (useSplitDwarf()) {
2006     DwarfStrDWOSectionSym =
2007         emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2008     DwarfAddrSectionSym =
2009         emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2010   }
2011   DwarfDebugRangeSectionSym =
2012       emitSectionSym(Asm, TLOF.getDwarfRangesSection(), "debug_range");
2013
2014   DwarfDebugLocSectionSym =
2015       emitSectionSym(Asm, TLOF.getDwarfLocSection(), "section_debug_loc");
2016
2017   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2018   emitSectionSym(Asm, TLOF.getDataSection());
2019 }
2020
2021 // Recursively emits a debug information entry.
2022 void DwarfDebug::emitDIE(DIE *Die, ArrayRef<DIEAbbrev *> Abbrevs) {
2023   // Get the abbreviation for this DIE.
2024   unsigned AbbrevNumber = Die->getAbbrevNumber();
2025   const DIEAbbrev *Abbrev = Abbrevs[AbbrevNumber - 1];
2026
2027   // Emit the code (index) for the abbreviation.
2028   if (Asm->isVerbose())
2029     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2030                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2031                                 Twine::utohexstr(Die->getSize()) + " " +
2032                                 dwarf::TagString(Abbrev->getTag()));
2033   Asm->EmitULEB128(AbbrevNumber);
2034
2035   const SmallVectorImpl<DIEValue *> &Values = Die->getValues();
2036   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2037
2038   // Emit the DIE attribute values.
2039   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2040     dwarf::Attribute Attr = AbbrevData[i].getAttribute();
2041     dwarf::Form Form = AbbrevData[i].getForm();
2042     assert(Form && "Too many attributes for DIE (check abbreviation)");
2043
2044     if (Asm->isVerbose())
2045       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2046
2047     switch (Attr) {
2048     case dwarf::DW_AT_abstract_origin:
2049     case dwarf::DW_AT_type:
2050     case dwarf::DW_AT_friend:
2051     case dwarf::DW_AT_specification:
2052     case dwarf::DW_AT_import:
2053     case dwarf::DW_AT_containing_type: {
2054       DIEEntry *E = cast<DIEEntry>(Values[i]);
2055       DIE *Origin = E->getEntry();
2056       unsigned Addr = Origin->getOffset();
2057       if (Form == dwarf::DW_FORM_ref_addr) {
2058         assert(!useSplitDwarf() && "TODO: dwo files can't have relocations.");
2059         // For DW_FORM_ref_addr, output the offset from beginning of debug info
2060         // section. Origin->getOffset() returns the offset from start of the
2061         // compile unit.
2062         CompileUnit *CU = CUDieMap.lookup(Origin->getUnit());
2063         assert(CU && "CUDie should belong to a CU.");
2064         Addr += CU->getDebugInfoOffset();
2065         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2066           Asm->EmitLabelPlusOffset(DwarfInfoSectionSym, Addr,
2067                                    DIEEntry::getRefAddrSize(Asm));
2068         else
2069           Asm->EmitLabelOffsetDifference(DwarfInfoSectionSym, Addr,
2070                                          DwarfInfoSectionSym,
2071                                          DIEEntry::getRefAddrSize(Asm));
2072       } else {
2073         // Make sure Origin belong to the same CU.
2074         assert(Die->getUnit() == Origin->getUnit() &&
2075                "The referenced DIE should belong to the same CU in ref4");
2076         Asm->EmitInt32(Addr);
2077       }
2078       break;
2079     }
2080     case dwarf::DW_AT_ranges: {
2081       // DW_AT_range Value encodes offset in debug_range section.
2082       DIELabel *V = cast<DIELabel>(Values[i]);
2083
2084       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2085         Asm->EmitSectionOffset(V->getValue(), DwarfDebugRangeSectionSym);
2086       else
2087         Asm->EmitLabelDifference(V->getValue(), DwarfDebugRangeSectionSym, 4);
2088       break;
2089     }
2090     case dwarf::DW_AT_location: {
2091       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2092         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2093           Asm->EmitSectionOffset(L->getValue(), DwarfDebugLocSectionSym);
2094         else
2095           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2096       } else {
2097         Values[i]->EmitValue(Asm, Form);
2098       }
2099       break;
2100     }
2101     case dwarf::DW_AT_accessibility: {
2102       if (Asm->isVerbose()) {
2103         DIEInteger *V = cast<DIEInteger>(Values[i]);
2104         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2105       }
2106       Values[i]->EmitValue(Asm, Form);
2107       break;
2108     }
2109     default:
2110       // Emit an attribute using the defined form.
2111       Values[i]->EmitValue(Asm, Form);
2112       break;
2113     }
2114   }
2115
2116   // Emit the DIE children if any.
2117   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2118     const std::vector<DIE *> &Children = Die->getChildren();
2119
2120     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2121       emitDIE(Children[j], Abbrevs);
2122
2123     if (Asm->isVerbose())
2124       Asm->OutStreamer.AddComment("End Of Children Mark");
2125     Asm->EmitInt8(0);
2126   }
2127 }
2128
2129 // Emit the various dwarf units to the unit section USection with
2130 // the abbreviations going into ASection.
2131 void DwarfUnits::emitUnits(DwarfDebug *DD, const MCSection *USection,
2132                            const MCSection *ASection,
2133                            const MCSymbol *ASectionSym) {
2134   Asm->OutStreamer.SwitchSection(USection);
2135   for (SmallVectorImpl<Unit *>::iterator I = CUs.begin(), E = CUs.end(); I != E;
2136        ++I) {
2137     Unit *TheCU = *I;
2138     DIE *Die = TheCU->getCUDie();
2139
2140     // Emit the compile units header.
2141     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2142                                                   TheCU->getUniqueID()));
2143
2144     // Emit size of content not including length itself
2145     Asm->OutStreamer.AddComment("Length of Unit");
2146     Asm->EmitInt32(TheCU->getHeaderSize() + Die->getSize());
2147
2148     TheCU->emitHeader(ASection, ASectionSym);
2149
2150     DD->emitDIE(Die, Abbreviations);
2151     Asm->OutStreamer.EmitLabel(
2152         Asm->GetTempSymbol(USection->getLabelEndName(), TheCU->getUniqueID()));
2153   }
2154 }
2155
2156 // Emit the debug info section.
2157 void DwarfDebug::emitDebugInfo() {
2158   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2159
2160   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2161                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2162                    DwarfAbbrevSectionSym);
2163 }
2164
2165 // Emit the abbreviation section.
2166 void DwarfDebug::emitAbbreviations() {
2167   if (!useSplitDwarf())
2168     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2169                 &Abbreviations);
2170   else
2171     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2172 }
2173
2174 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2175                              std::vector<DIEAbbrev *> *Abbrevs) {
2176   // Check to see if it is worth the effort.
2177   if (!Abbrevs->empty()) {
2178     // Start the debug abbrev section.
2179     Asm->OutStreamer.SwitchSection(Section);
2180
2181     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2182     Asm->OutStreamer.EmitLabel(Begin);
2183
2184     // For each abbrevation.
2185     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2186       // Get abbreviation data
2187       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2188
2189       // Emit the abbrevations code (base 1 index.)
2190       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2191
2192       // Emit the abbreviations data.
2193       Abbrev->Emit(Asm);
2194     }
2195
2196     // Mark end of abbreviations.
2197     Asm->EmitULEB128(0, "EOM(3)");
2198
2199     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2200     Asm->OutStreamer.EmitLabel(End);
2201   }
2202 }
2203
2204 // Emit the last address of the section and the end of the line matrix.
2205 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2206   // Define last address of section.
2207   Asm->OutStreamer.AddComment("Extended Op");
2208   Asm->EmitInt8(0);
2209
2210   Asm->OutStreamer.AddComment("Op size");
2211   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2212   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2213   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2214
2215   Asm->OutStreamer.AddComment("Section end label");
2216
2217   Asm->OutStreamer.EmitSymbolValue(
2218       Asm->GetTempSymbol("section_end", SectionEnd),
2219       Asm->getDataLayout().getPointerSize());
2220
2221   // Mark end of matrix.
2222   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2223   Asm->EmitInt8(0);
2224   Asm->EmitInt8(1);
2225   Asm->EmitInt8(1);
2226 }
2227
2228 // Emit visible names into a hashed accelerator table section.
2229 void DwarfDebug::emitAccelNames() {
2230   DwarfAccelTable AT(
2231       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2232   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2233                                                E = getUnits().end();
2234        I != E; ++I) {
2235     Unit *TheCU = *I;
2236     const StringMap<std::vector<const DIE *> > &Names = TheCU->getAccelNames();
2237     for (StringMap<std::vector<const DIE *> >::const_iterator
2238              GI = Names.begin(),
2239              GE = Names.end();
2240          GI != GE; ++GI) {
2241       StringRef Name = GI->getKey();
2242       const std::vector<const DIE *> &Entities = GI->second;
2243       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2244                                                     DE = Entities.end();
2245            DI != DE; ++DI)
2246         AT.AddName(Name, *DI);
2247     }
2248   }
2249
2250   AT.FinalizeTable(Asm, "Names");
2251   Asm->OutStreamer.SwitchSection(
2252       Asm->getObjFileLowering().getDwarfAccelNamesSection());
2253   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2254   Asm->OutStreamer.EmitLabel(SectionBegin);
2255
2256   // Emit the full data.
2257   AT.Emit(Asm, SectionBegin, &InfoHolder);
2258 }
2259
2260 // Emit objective C classes and categories into a hashed accelerator table
2261 // section.
2262 void DwarfDebug::emitAccelObjC() {
2263   DwarfAccelTable AT(
2264       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2265   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2266                                                E = getUnits().end();
2267        I != E; ++I) {
2268     Unit *TheCU = *I;
2269     const StringMap<std::vector<const DIE *> > &Names = TheCU->getAccelObjC();
2270     for (StringMap<std::vector<const DIE *> >::const_iterator
2271              GI = Names.begin(),
2272              GE = Names.end();
2273          GI != GE; ++GI) {
2274       StringRef Name = GI->getKey();
2275       const std::vector<const DIE *> &Entities = GI->second;
2276       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2277                                                     DE = Entities.end();
2278            DI != DE; ++DI)
2279         AT.AddName(Name, *DI);
2280     }
2281   }
2282
2283   AT.FinalizeTable(Asm, "ObjC");
2284   Asm->OutStreamer.SwitchSection(
2285       Asm->getObjFileLowering().getDwarfAccelObjCSection());
2286   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2287   Asm->OutStreamer.EmitLabel(SectionBegin);
2288
2289   // Emit the full data.
2290   AT.Emit(Asm, SectionBegin, &InfoHolder);
2291 }
2292
2293 // Emit namespace dies into a hashed accelerator table.
2294 void DwarfDebug::emitAccelNamespaces() {
2295   DwarfAccelTable AT(
2296       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2297   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2298                                                E = getUnits().end();
2299        I != E; ++I) {
2300     Unit *TheCU = *I;
2301     const StringMap<std::vector<const DIE *> > &Names =
2302         TheCU->getAccelNamespace();
2303     for (StringMap<std::vector<const DIE *> >::const_iterator
2304              GI = Names.begin(),
2305              GE = Names.end();
2306          GI != GE; ++GI) {
2307       StringRef Name = GI->getKey();
2308       const std::vector<const DIE *> &Entities = GI->second;
2309       for (std::vector<const DIE *>::const_iterator DI = Entities.begin(),
2310                                                     DE = Entities.end();
2311            DI != DE; ++DI)
2312         AT.AddName(Name, *DI);
2313     }
2314   }
2315
2316   AT.FinalizeTable(Asm, "namespac");
2317   Asm->OutStreamer.SwitchSection(
2318       Asm->getObjFileLowering().getDwarfAccelNamespaceSection());
2319   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2320   Asm->OutStreamer.EmitLabel(SectionBegin);
2321
2322   // Emit the full data.
2323   AT.Emit(Asm, SectionBegin, &InfoHolder);
2324 }
2325
2326 // Emit type dies into a hashed accelerator table.
2327 void DwarfDebug::emitAccelTypes() {
2328   std::vector<DwarfAccelTable::Atom> Atoms;
2329   Atoms.push_back(
2330       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4));
2331   Atoms.push_back(
2332       DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag, dwarf::DW_FORM_data2));
2333   Atoms.push_back(
2334       DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags, dwarf::DW_FORM_data1));
2335   DwarfAccelTable AT(Atoms);
2336   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2337                                                E = getUnits().end();
2338        I != E; ++I) {
2339     Unit *TheCU = *I;
2340     const StringMap<std::vector<std::pair<const DIE *, unsigned> > > &Names =
2341         TheCU->getAccelTypes();
2342     for (StringMap<
2343              std::vector<std::pair<const DIE *, unsigned> > >::const_iterator
2344              GI = Names.begin(),
2345              GE = Names.end();
2346          GI != GE; ++GI) {
2347       StringRef Name = GI->getKey();
2348       const std::vector<std::pair<const DIE *, unsigned> > &Entities =
2349           GI->second;
2350       for (std::vector<std::pair<const DIE *, unsigned> >::const_iterator
2351                DI = Entities.begin(),
2352                DE = Entities.end();
2353            DI != DE; ++DI)
2354         AT.AddName(Name, DI->first, DI->second);
2355     }
2356   }
2357
2358   AT.FinalizeTable(Asm, "types");
2359   Asm->OutStreamer.SwitchSection(
2360       Asm->getObjFileLowering().getDwarfAccelTypesSection());
2361   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2362   Asm->OutStreamer.EmitLabel(SectionBegin);
2363
2364   // Emit the full data.
2365   AT.Emit(Asm, SectionBegin, &InfoHolder);
2366 }
2367
2368 // Public name handling.
2369 // The format for the various pubnames:
2370 //
2371 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2372 // for the DIE that is named.
2373 //
2374 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2375 // into the CU and the index value is computed according to the type of value
2376 // for the DIE that is named.
2377 //
2378 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2379 // it's the offset within the debug_info/debug_types dwo section, however, the
2380 // reference in the pubname header doesn't change.
2381
2382 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2383 static dwarf::PubIndexEntryDescriptor computeIndexValue(Unit *CU,
2384                                                         const DIE *Die) {
2385   dwarf::GDBIndexEntryLinkage Linkage = dwarf::GIEL_STATIC;
2386
2387   // We could have a specification DIE that has our most of our knowledge,
2388   // look for that now.
2389   DIEValue *SpecVal = Die->findAttribute(dwarf::DW_AT_specification);
2390   if (SpecVal) {
2391     DIE *SpecDIE = cast<DIEEntry>(SpecVal)->getEntry();
2392     if (SpecDIE->findAttribute(dwarf::DW_AT_external))
2393       Linkage = dwarf::GIEL_EXTERNAL;
2394   } else if (Die->findAttribute(dwarf::DW_AT_external))
2395     Linkage = dwarf::GIEL_EXTERNAL;
2396
2397   switch (Die->getTag()) {
2398   case dwarf::DW_TAG_class_type:
2399   case dwarf::DW_TAG_structure_type:
2400   case dwarf::DW_TAG_union_type:
2401   case dwarf::DW_TAG_enumeration_type:
2402     return dwarf::PubIndexEntryDescriptor(
2403         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2404                               ? dwarf::GIEL_STATIC
2405                               : dwarf::GIEL_EXTERNAL);
2406   case dwarf::DW_TAG_typedef:
2407   case dwarf::DW_TAG_base_type:
2408   case dwarf::DW_TAG_subrange_type:
2409     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2410   case dwarf::DW_TAG_namespace:
2411     return dwarf::GIEK_TYPE;
2412   case dwarf::DW_TAG_subprogram:
2413     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2414   case dwarf::DW_TAG_constant:
2415   case dwarf::DW_TAG_variable:
2416     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2417   case dwarf::DW_TAG_enumerator:
2418     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2419                                           dwarf::GIEL_STATIC);
2420   default:
2421     return dwarf::GIEK_NONE;
2422   }
2423 }
2424
2425 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2426 ///
2427 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2428   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2429   const MCSection *PSec =
2430       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2431                : Asm->getObjFileLowering().getDwarfPubNamesSection();
2432
2433   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2434                                                E = getUnits().end();
2435        I != E; ++I) {
2436     Unit *TheCU = *I;
2437     unsigned ID = TheCU->getUniqueID();
2438
2439     // Start the dwarf pubnames section.
2440     Asm->OutStreamer.SwitchSection(PSec);
2441
2442     // Emit a label so we can reference the beginning of this pubname section.
2443     if (GnuStyle)
2444       Asm->OutStreamer.EmitLabel(
2445           Asm->GetTempSymbol("gnu_pubnames", TheCU->getUniqueID()));
2446
2447     // Emit the header.
2448     Asm->OutStreamer.AddComment("Length of Public Names Info");
2449     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2450                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2451
2452     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2453
2454     Asm->OutStreamer.AddComment("DWARF Version");
2455     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2456
2457     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2458     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2459                            DwarfInfoSectionSym);
2460
2461     Asm->OutStreamer.AddComment("Compilation Unit Length");
2462     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2463                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2464                              4);
2465
2466     // Emit the pubnames for this compilation unit.
2467     const StringMap<const DIE *> &Globals = TheCU->getGlobalNames();
2468     for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2469                                                 GE = Globals.end();
2470          GI != GE; ++GI) {
2471       const char *Name = GI->getKeyData();
2472       const DIE *Entity = GI->second;
2473
2474       Asm->OutStreamer.AddComment("DIE offset");
2475       Asm->EmitInt32(Entity->getOffset());
2476
2477       if (GnuStyle) {
2478         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2479         Asm->OutStreamer.AddComment(
2480             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2481             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2482         Asm->EmitInt8(Desc.toBits());
2483       }
2484
2485       if (Asm->isVerbose())
2486         Asm->OutStreamer.AddComment("External Name");
2487       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2488     }
2489
2490     Asm->OutStreamer.AddComment("End Mark");
2491     Asm->EmitInt32(0);
2492     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2493   }
2494 }
2495
2496 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2497   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2498   const MCSection *PSec =
2499       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2500                : Asm->getObjFileLowering().getDwarfPubTypesSection();
2501
2502   for (SmallVectorImpl<Unit *>::const_iterator I = getUnits().begin(),
2503                                                E = getUnits().end();
2504        I != E; ++I) {
2505     Unit *TheCU = *I;
2506     // Start the dwarf pubtypes section.
2507     Asm->OutStreamer.SwitchSection(PSec);
2508
2509     // Emit a label so we can reference the beginning of this pubtype section.
2510     if (GnuStyle)
2511       Asm->OutStreamer.EmitLabel(
2512           Asm->GetTempSymbol("gnu_pubtypes", TheCU->getUniqueID()));
2513
2514     // Emit the header.
2515     Asm->OutStreamer.AddComment("Length of Public Types Info");
2516     Asm->EmitLabelDifference(
2517         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2518         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2519
2520     Asm->OutStreamer.EmitLabel(
2521         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2522
2523     if (Asm->isVerbose())
2524       Asm->OutStreamer.AddComment("DWARF Version");
2525     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2526
2527     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2528     Asm->EmitSectionOffset(
2529         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2530         DwarfInfoSectionSym);
2531
2532     Asm->OutStreamer.AddComment("Compilation Unit Length");
2533     Asm->EmitLabelDifference(
2534         Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2535         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2536
2537     // Emit the pubtypes.
2538     const StringMap<const DIE *> &Globals = TheCU->getGlobalTypes();
2539     for (StringMap<const DIE *>::const_iterator GI = Globals.begin(),
2540                                                 GE = Globals.end();
2541          GI != GE; ++GI) {
2542       const char *Name = GI->getKeyData();
2543       const DIE *Entity = GI->second;
2544
2545       if (Asm->isVerbose())
2546         Asm->OutStreamer.AddComment("DIE offset");
2547       Asm->EmitInt32(Entity->getOffset());
2548
2549       if (GnuStyle) {
2550         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2551         Asm->OutStreamer.AddComment(
2552             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2553             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2554         Asm->EmitInt8(Desc.toBits());
2555       }
2556
2557       if (Asm->isVerbose())
2558         Asm->OutStreamer.AddComment("External Name");
2559
2560       // Emit the name with a terminating null byte.
2561       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2562     }
2563
2564     Asm->OutStreamer.AddComment("End Mark");
2565     Asm->EmitInt32(0);
2566     Asm->OutStreamer.EmitLabel(
2567         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2568   }
2569 }
2570
2571 // Emit strings into a string section.
2572 void DwarfUnits::emitStrings(const MCSection *StrSection,
2573                              const MCSection *OffsetSection = NULL,
2574                              const MCSymbol *StrSecSym = NULL) {
2575
2576   if (StringPool.empty())
2577     return;
2578
2579   // Start the dwarf str section.
2580   Asm->OutStreamer.SwitchSection(StrSection);
2581
2582   // Get all of the string pool entries and put them in an array by their ID so
2583   // we can sort them.
2584   SmallVector<
2585       std::pair<unsigned, StringMapEntry<std::pair<MCSymbol *, unsigned> > *>,
2586       64> Entries;
2587
2588   for (StringMap<std::pair<MCSymbol *, unsigned> >::iterator
2589            I = StringPool.begin(),
2590            E = StringPool.end();
2591        I != E; ++I)
2592     Entries.push_back(std::make_pair(I->second.second, &*I));
2593
2594   array_pod_sort(Entries.begin(), Entries.end());
2595
2596   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2597     // Emit a label for reference from debug information entries.
2598     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2599
2600     // Emit the string itself with a terminating null byte.
2601     Asm->OutStreamer.EmitBytes(
2602         StringRef(Entries[i].second->getKeyData(),
2603                   Entries[i].second->getKeyLength() + 1));
2604   }
2605
2606   // If we've got an offset section go ahead and emit that now as well.
2607   if (OffsetSection) {
2608     Asm->OutStreamer.SwitchSection(OffsetSection);
2609     unsigned offset = 0;
2610     unsigned size = 4; // FIXME: DWARF64 is 8.
2611     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2612       Asm->OutStreamer.EmitIntValue(offset, size);
2613       offset += Entries[i].second->getKeyLength() + 1;
2614     }
2615   }
2616 }
2617
2618
2619 // Emit addresses into the section given.
2620 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2621
2622   if (AddressPool.empty())
2623     return;
2624
2625   // Start the dwarf addr section.
2626   Asm->OutStreamer.SwitchSection(AddrSection);
2627
2628   // Order the address pool entries by ID
2629   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2630
2631   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2632                                                     E = AddressPool.end();
2633        I != E; ++I)
2634     Entries[I->second] = I->first;
2635
2636   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2637     // Emit an expression for reference from debug information entries.
2638     if (const MCExpr *Expr = Entries[i])
2639       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2640     else
2641       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2642   }
2643 }
2644
2645 // Emit visible names into a debug str section.
2646 void DwarfDebug::emitDebugStr() {
2647   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2648   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2649 }
2650
2651 // Emit locations into the debug loc section.
2652 void DwarfDebug::emitDebugLoc() {
2653   if (DotDebugLocEntries.empty())
2654     return;
2655
2656   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2657            I = DotDebugLocEntries.begin(),
2658            E = DotDebugLocEntries.end();
2659        I != E; ++I) {
2660     DotDebugLocEntry &Entry = *I;
2661     if (I + 1 != DotDebugLocEntries.end())
2662       Entry.Merge(I + 1);
2663   }
2664
2665   // Start the dwarf loc section.
2666   Asm->OutStreamer.SwitchSection(
2667       Asm->getObjFileLowering().getDwarfLocSection());
2668   unsigned char Size = Asm->getDataLayout().getPointerSize();
2669   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2670   unsigned index = 1;
2671   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2672            I = DotDebugLocEntries.begin(),
2673            E = DotDebugLocEntries.end();
2674        I != E; ++I, ++index) {
2675     DotDebugLocEntry &Entry = *I;
2676     if (Entry.isMerged())
2677       continue;
2678     if (Entry.isEmpty()) {
2679       Asm->OutStreamer.EmitIntValue(0, Size);
2680       Asm->OutStreamer.EmitIntValue(0, Size);
2681       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2682     } else {
2683       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2684       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2685       DIVariable DV(Entry.getVariable());
2686       Asm->OutStreamer.AddComment("Loc expr size");
2687       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2688       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2689       Asm->EmitLabelDifference(end, begin, 2);
2690       Asm->OutStreamer.EmitLabel(begin);
2691       if (Entry.isInt()) {
2692         DIBasicType BTy(DV.getType());
2693         if (BTy.Verify() && (BTy.getEncoding() == dwarf::DW_ATE_signed ||
2694                              BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2695           Asm->OutStreamer.AddComment("DW_OP_consts");
2696           Asm->EmitInt8(dwarf::DW_OP_consts);
2697           Asm->EmitSLEB128(Entry.getInt());
2698         } else {
2699           Asm->OutStreamer.AddComment("DW_OP_constu");
2700           Asm->EmitInt8(dwarf::DW_OP_constu);
2701           Asm->EmitULEB128(Entry.getInt());
2702         }
2703       } else if (Entry.isLocation()) {
2704         MachineLocation Loc = Entry.getLoc();
2705         if (!DV.hasComplexAddress())
2706           // Regular entry.
2707           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2708         else {
2709           // Complex address entry.
2710           unsigned N = DV.getNumAddrElements();
2711           unsigned i = 0;
2712           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2713             if (Loc.getOffset()) {
2714               i = 2;
2715               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2716               Asm->OutStreamer.AddComment("DW_OP_deref");
2717               Asm->EmitInt8(dwarf::DW_OP_deref);
2718               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2719               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2720               Asm->EmitSLEB128(DV.getAddrElement(1));
2721             } else {
2722               // If first address element is OpPlus then emit
2723               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2724               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2725               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2726               i = 2;
2727             }
2728           } else {
2729             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2730           }
2731
2732           // Emit remaining complex address elements.
2733           for (; i < N; ++i) {
2734             uint64_t Element = DV.getAddrElement(i);
2735             if (Element == DIBuilder::OpPlus) {
2736               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2737               Asm->EmitULEB128(DV.getAddrElement(++i));
2738             } else if (Element == DIBuilder::OpDeref) {
2739               if (!Loc.isReg())
2740                 Asm->EmitInt8(dwarf::DW_OP_deref);
2741             } else
2742               llvm_unreachable("unknown Opcode found in complex address");
2743           }
2744         }
2745       }
2746       // else ... ignore constant fp. There is not any good way to
2747       // to represent them here in dwarf.
2748       Asm->OutStreamer.EmitLabel(end);
2749     }
2750   }
2751 }
2752
2753 struct SymbolCUSorter {
2754   SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2755   const MCStreamer &Streamer;
2756
2757   bool operator()(const SymbolCU &A, const SymbolCU &B) {
2758     unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2759     unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2760
2761     // Symbols with no order assigned should be placed at the end.
2762     // (e.g. section end labels)
2763     if (IA == 0)
2764       IA = (unsigned)(-1);
2765     if (IB == 0)
2766       IB = (unsigned)(-1);
2767     return IA < IB;
2768   }
2769 };
2770
2771 static bool CUSort(const Unit *A, const Unit *B) {
2772   return (A->getUniqueID() < B->getUniqueID());
2773 }
2774
2775 struct ArangeSpan {
2776   const MCSymbol *Start, *End;
2777 };
2778
2779 // Emit a debug aranges section, containing a CU lookup for any
2780 // address we can tie back to a CU.
2781 void DwarfDebug::emitDebugARanges() {
2782   // Start the dwarf aranges section.
2783   Asm->OutStreamer.SwitchSection(
2784       Asm->getObjFileLowering().getDwarfARangesSection());
2785
2786   typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2787
2788   SpansType Spans;
2789
2790   // Build a list of sections used.
2791   std::vector<const MCSection *> Sections;
2792   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2793        it++) {
2794     const MCSection *Section = it->first;
2795     Sections.push_back(Section);
2796   }
2797
2798   // Sort the sections into order.
2799   // This is only done to ensure consistent output order across different runs.
2800   std::sort(Sections.begin(), Sections.end(), SectionSort);
2801
2802   // Build a set of address spans, sorted by CU.
2803   for (size_t SecIdx = 0; SecIdx < Sections.size(); SecIdx++) {
2804     const MCSection *Section = Sections[SecIdx];
2805     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2806     if (List.size() < 2)
2807       continue;
2808
2809     // Sort the symbols by offset within the section.
2810     SymbolCUSorter sorter(Asm->OutStreamer);
2811     std::sort(List.begin(), List.end(), sorter);
2812
2813     // If we have no section (e.g. common), just write out
2814     // individual spans for each symbol.
2815     if (Section == NULL) {
2816       for (size_t n = 0; n < List.size(); n++) {
2817         const SymbolCU &Cur = List[n];
2818
2819         ArangeSpan Span;
2820         Span.Start = Cur.Sym;
2821         Span.End = NULL;
2822         if (Cur.CU)
2823           Spans[Cur.CU].push_back(Span);
2824       }
2825     } else {
2826       // Build spans between each label.
2827       const MCSymbol *StartSym = List[0].Sym;
2828       for (size_t n = 1; n < List.size(); n++) {
2829         const SymbolCU &Prev = List[n - 1];
2830         const SymbolCU &Cur = List[n];
2831
2832         // Try and build the longest span we can within the same CU.
2833         if (Cur.CU != Prev.CU) {
2834           ArangeSpan Span;
2835           Span.Start = StartSym;
2836           Span.End = Cur.Sym;
2837           Spans[Prev.CU].push_back(Span);
2838           StartSym = Cur.Sym;
2839         }
2840       }
2841     }
2842   }
2843
2844   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2845   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2846
2847   // Build a list of CUs used.
2848   std::vector<CompileUnit *> CUs;
2849   for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2850     CompileUnit *CU = it->first;
2851     CUs.push_back(CU);
2852   }
2853
2854   // Sort the CU list (again, to ensure consistent output order).
2855   std::sort(CUs.begin(), CUs.end(), CUSort);
2856
2857   // Emit an arange table for each CU we used.
2858   for (size_t CUIdx = 0; CUIdx < CUs.size(); CUIdx++) {
2859     CompileUnit *CU = CUs[CUIdx];
2860     std::vector<ArangeSpan> &List = Spans[CU];
2861
2862     // Emit size of content not including length itself.
2863     unsigned ContentSize =
2864         sizeof(int16_t) + // DWARF ARange version number
2865         sizeof(int32_t) + // Offset of CU in the .debug_info section
2866         sizeof(int8_t) +  // Pointer Size (in bytes)
2867         sizeof(int8_t);   // Segment Size (in bytes)
2868
2869     unsigned TupleSize = PtrSize * 2;
2870
2871     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2872     unsigned Padding = 0;
2873     while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2874       Padding++;
2875
2876     ContentSize += Padding;
2877     ContentSize += (List.size() + 1) * TupleSize;
2878
2879     // For each compile unit, write the list of spans it covers.
2880     Asm->OutStreamer.AddComment("Length of ARange Set");
2881     Asm->EmitInt32(ContentSize);
2882     Asm->OutStreamer.AddComment("DWARF Arange version number");
2883     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2884     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2885     Asm->EmitSectionOffset(
2886         Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2887         DwarfInfoSectionSym);
2888     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2889     Asm->EmitInt8(PtrSize);
2890     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2891     Asm->EmitInt8(0);
2892
2893     for (unsigned n = 0; n < Padding; n++)
2894       Asm->EmitInt8(0xff);
2895
2896     for (unsigned n = 0; n < List.size(); n++) {
2897       const ArangeSpan &Span = List[n];
2898       Asm->EmitLabelReference(Span.Start, PtrSize);
2899
2900       // Calculate the size as being from the span start to it's end.
2901       if (Span.End) {
2902         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2903       } else {
2904         // For symbols without an end marker (e.g. common), we
2905         // write a single arange entry containing just that one symbol.
2906         uint64_t Size = SymSize[Span.Start];
2907         if (Size == 0)
2908           Size = 1;
2909
2910         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2911       }
2912     }
2913
2914     Asm->OutStreamer.AddComment("ARange terminator");
2915     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2916     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2917   }
2918 }
2919
2920 // Emit visible names into a debug ranges section.
2921 void DwarfDebug::emitDebugRanges() {
2922   // Start the dwarf ranges section.
2923   Asm->OutStreamer.SwitchSection(
2924       Asm->getObjFileLowering().getDwarfRangesSection());
2925   unsigned char Size = Asm->getDataLayout().getPointerSize();
2926   for (uint32_t i = 0, e = DebugRangeSymbols.size(); i < e; ++i) {
2927     // Only emit a symbol for every range pair for now.
2928     // FIXME: Make this per range list.
2929     if ((i % 2) == 0)
2930       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_ranges", i));
2931
2932     const MCSymbol *I = DebugRangeSymbols[i];
2933     if (I)
2934       Asm->OutStreamer.EmitSymbolValue(I, Size);
2935     else
2936       Asm->OutStreamer.EmitIntValue(0, Size);
2937   }
2938 }
2939
2940 // Emit visible names into a debug macinfo section.
2941 void DwarfDebug::emitDebugMacInfo() {
2942   if (const MCSection *LineInfo =
2943           Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2944     // Start the dwarf macinfo section.
2945     Asm->OutStreamer.SwitchSection(LineInfo);
2946   }
2947 }
2948
2949 // DWARF5 Experimental Separate Dwarf emitters.
2950
2951 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2952 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2953 // DW_AT_ranges_base, DW_AT_addr_base.
2954 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2955
2956   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2957   CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2958                                        Asm, this, &SkeletonHolder);
2959
2960   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2961                         CU->getNode().getSplitDebugFilename());
2962
2963   // Relocate to the beginning of the addr_base section, else 0 for the
2964   // beginning of the one for this compile unit.
2965   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2966     NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_addr_base,
2967                            DwarfAddrSectionSym);
2968   else
2969     NewCU->addSectionOffset(Die, dwarf::DW_AT_GNU_addr_base, 0);
2970
2971   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2972   // into an entity. We're using 0, or a NULL label for this.
2973   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2974
2975   // DW_AT_stmt_list is a offset of line number information for this
2976   // compile unit in debug_line section.
2977   // FIXME: Should handle multiple compile units.
2978   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2979     NewCU->addSectionLabel(Die, dwarf::DW_AT_stmt_list,
2980                            DwarfLineSectionSym);
2981   else
2982     NewCU->addSectionOffset(Die, dwarf::DW_AT_stmt_list, 0);
2983
2984   if (!CompilationDir.empty())
2985     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2986
2987   // Flags to let the linker know we have emitted new style pubnames.
2988   if (GenerateGnuPubSections) {
2989     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2990       NewCU->addSectionLabel(
2991           Die, dwarf::DW_AT_GNU_pubnames,
2992           Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2993     else
2994       NewCU->addSectionDelta(
2995           Die, dwarf::DW_AT_GNU_pubnames,
2996           Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2997           DwarfGnuPubNamesSectionSym);
2998
2999     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3000       NewCU->addSectionLabel(
3001           Die, dwarf::DW_AT_GNU_pubtypes,
3002           Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
3003     else
3004       NewCU->addSectionDelta(
3005           Die, dwarf::DW_AT_GNU_pubtypes,
3006           Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
3007           DwarfGnuPubTypesSectionSym);
3008   }
3009
3010   // Flag if we've emitted any ranges and their location for the compile unit.
3011   if (DebugRangeSymbols.size()) {
3012     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
3013       NewCU->addSectionLabel(Die, dwarf::DW_AT_GNU_ranges_base,
3014                              DwarfDebugRangeSectionSym);
3015     else
3016       NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
3017                      0);
3018   }
3019
3020   SkeletonHolder.addUnit(NewCU);
3021
3022   return NewCU;
3023 }
3024
3025 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
3026   assert(useSplitDwarf() && "No split dwarf debug info?");
3027   emitAbbrevs(Section, &SkeletonAbbrevs);
3028 }
3029
3030 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3031 // compile units that would normally be in debug_info.
3032 void DwarfDebug::emitDebugInfoDWO() {
3033   assert(useSplitDwarf() && "No split dwarf debug info?");
3034   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3035                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3036                        DwarfAbbrevDWOSectionSym);
3037 }
3038
3039 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3040 // abbreviations for the .debug_info.dwo section.
3041 void DwarfDebug::emitDebugAbbrevDWO() {
3042   assert(useSplitDwarf() && "No split dwarf?");
3043   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3044               &Abbreviations);
3045 }
3046
3047 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3048 // string section and is identical in format to traditional .debug_str
3049 // sections.
3050 void DwarfDebug::emitDebugStrDWO() {
3051   assert(useSplitDwarf() && "No split dwarf?");
3052   const MCSection *OffSec =
3053       Asm->getObjFileLowering().getDwarfStrOffDWOSection();
3054   const MCSymbol *StrSym = DwarfStrSectionSym;
3055   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3056                          OffSec, StrSym);
3057 }
3058
3059 void DwarfDebug::addTypeUnitType(uint16_t Language, DIE *RefDie,
3060                                  DICompositeType CTy) {
3061   DenseMap<const MDNode *,
3062            std::pair<uint64_t, SmallVectorImpl<DIE *> *> >::iterator I =
3063       TypeUnits.find(CTy);
3064   SmallVector<DIE *, 8> References;
3065   References.push_back(RefDie);
3066   if (I != TypeUnits.end()) {
3067     if (I->second.second) {
3068       I->second.second->push_back(RefDie);
3069       return;
3070     }
3071   } else {
3072     DIE *UnitDie = new DIE(dwarf::DW_TAG_type_unit);
3073     TypeUnit *NewTU = new TypeUnit(GlobalCUIndexCount++, UnitDie, Language, Asm,
3074                                    this, &InfoHolder);
3075     NewTU->addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
3076                    Language);
3077
3078     // Register the type in the TypeUnits map with a vector of references to be
3079     // populated whenever a reference is required.
3080     I = TypeUnits.insert(std::make_pair(CTy, std::make_pair(0, &References)))
3081             .first;
3082
3083     // Construct the type, this may, recursively, require more type units that
3084     // may in turn require this type again - in which case they will add DIEs to
3085     // the References vector.
3086     DIE *Die = NewTU->createTypeDIE(CTy);
3087
3088     if (GenerateODRHash && shouldAddODRHash(NewTU, Die))
3089       NewTU->addUInt(UnitDie, dwarf::DW_AT_GNU_odr_signature,
3090                      dwarf::DW_FORM_data8,
3091                      DIEHash().computeDIEODRSignature(*Die));
3092     // FIXME: This won't handle circularly referential structures, as the DIE
3093     // may have references to other DIEs still under construction and missing
3094     // their signature. Hashing should walk through the signatures to their
3095     // referenced type, or possibly walk the precomputed hashes of related types
3096     // at the end.
3097     uint64_t Signature = DIEHash().computeTypeSignature(*Die);
3098
3099     // Remove the References vector and add the type hash.
3100     I->second.first = Signature;
3101     I->second.second = NULL;
3102
3103     InfoHolder.addUnit(NewTU);
3104   }
3105
3106   // Populate all the signatures.
3107   for (unsigned i = 0, e = References.size(); i != e; ++i) {
3108     CUMap.begin()->second->addUInt(References[i], dwarf::DW_AT_signature,
3109                                    dwarf::DW_FORM_ref_sig8, I->second.first);
3110   }
3111 }