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