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