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 a global name.
 773   TheCU->addGlobalName(SP.getName(), SubprogramDie);
 774 }
 775
 776 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 777                                             const MDNode *N) {
 778   DIImportedEntity Module(N);
 779   if (!Module.Verify())
 780     return;
 781   if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
 782     constructImportedEntityDIE(TheCU, Module, D);
 783 }
 784
 785 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
 786                                             DIE *Context) {
 787   DIImportedEntity Module(N);
 788   if (!Module.Verify())
 789     return;
 790   return constructImportedEntityDIE(TheCU, Module, Context);
 791 }
 792
 793 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 794                                             const DIImportedEntity &Module,
 795                                             DIE *Context) {
 796   assert(Module.Verify() &&
 797          "Use one of the MDNode * overloads to handle invalid metadata");
 798   assert(Context && "Should always have a context for an imported_module");
 799   DIE *IMDie = new DIE(Module.getTag());
 800   TheCU->insertDIE(Module, IMDie);
 801   DIE *EntityDie;
 802   DIDescriptor Entity = Module.getEntity();
 803   if (Entity.isNameSpace())
 804     EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
 805   else if (Entity.isSubprogram())
 806     EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
 807   else if (Entity.isType())
 808     EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
 809   else
 810     EntityDie = TheCU->getDIE(Entity);
 811   unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
 812                                         Module.getContext().getDirectory(),
 813                                         TheCU->getUniqueID());
 814   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
 815   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
 816   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
 817                      EntityDie);
 818   StringRef Name = Module.getName();
 819   if (!Name.empty())
 820     TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
 821   Context->addChild(IMDie);
 822 }
 823
 824 // Emit all Dwarf sections that should come prior to the content. Create
 825 // global DIEs and emit initial debug info sections. This is invoked by
 826 // the target AsmPrinter.
 827 void DwarfDebug::beginModule() {
 828   if (DisableDebugInfoPrinting)
 829     return;
 830
 831   const Module *M = MMI->getModule();
 832
 833   // If module has named metadata anchors then use them, otherwise scan the
 834   // module using debug info finder to collect debug info.
 835   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 836   if (!CU_Nodes)
 837     return;
 838   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
 839
 840   // Emit initial sections so we can reference labels later.
 841   emitSectionLabels();
 842
 843   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 844     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 845     CompileUnit *CU = constructCompileUnit(CUNode);
 846     DIArray ImportedEntities = CUNode.getImportedEntities();
 847     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 848       ScopesWithImportedEntities.push_back(std::make_pair(
 849           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
 850           ImportedEntities.getElement(i)));
 851     std::sort(ScopesWithImportedEntities.begin(),
 852               ScopesWithImportedEntities.end(), less_first());
 853     DIArray GVs = CUNode.getGlobalVariables();
 854     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 855       CU->createGlobalVariableDIE(GVs.getElement(i));
 856     DIArray SPs = CUNode.getSubprograms();
 857     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 858       constructSubprogramDIE(CU, SPs.getElement(i));
 859     DIArray EnumTypes = CUNode.getEnumTypes();
 860     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 861       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 862     DIArray RetainedTypes = CUNode.getRetainedTypes();
 863     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 864       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 865     // Emit imported_modules last so that the relevant context is already
 866     // available.
 867     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 868       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
 869   }
 870
 871   // Tell MMI that we have debug info.
 872   MMI->setDebugInfoAvailability(true);
 873
 874   // Prime section data.
 875   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 876 }
 877
 878 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 879 void DwarfDebug::computeInlinedDIEs() {
 880   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 881   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 882          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 883     DIE *ISP = *AI;
 884     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 885   }
 886   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 887          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 888     DIE *ISP = AI->second;
 889     if (InlinedSubprogramDIEs.count(ISP))
 890       continue;
 891     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 892   }
 893 }
 894
 895 // Collect info for variables that were optimized out.
 896 void DwarfDebug::collectDeadVariables() {
 897   const Module *M = MMI->getModule();
 898   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 899
 900   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 901     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 902       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 903       DIArray Subprograms = TheCU.getSubprograms();
 904       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 905         DISubprogram SP(Subprograms.getElement(i));
 906         if (ProcessedSPNodes.count(SP) != 0) continue;
 907         if (!SP.isSubprogram()) continue;
 908         if (!SP.isDefinition()) continue;
 909         DIArray Variables = SP.getVariables();
 910         if (Variables.getNumElements() == 0) continue;
 911
 912         LexicalScope *Scope =
 913           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 914         DeadFnScopeMap[SP] = Scope;
 915
 916         // Construct subprogram DIE and add variables DIEs.
 917         CompileUnit *SPCU = CUMap.lookup(TheCU);
 918         assert(SPCU && "Unable to find Compile Unit!");
 919         constructSubprogramDIE(SPCU, SP);
 920         DIE *ScopeDIE = SPCU->getDIE(SP);
 921         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 922           DIVariable DV(Variables.getElement(vi));
 923           if (!DV.isVariable()) continue;
 924           DbgVariable NewVar(DV, NULL);
 925           if (DIE *VariableDIE =
 926               SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
 927             ScopeDIE->addChild(VariableDIE);
 928         }
 929       }
 930     }
 931   }
 932   DeleteContainerSeconds(DeadFnScopeMap);
 933 }
 934
 935 // Type Signature [7.27] and ODR Hash code.
 936
 937 /// \brief Grabs the string in whichever attribute is passed in and returns
 938 /// a reference to it. Returns "" if the attribute doesn't exist.
 939 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
 940   DIEValue *V = Die->findAttribute(Attr);
 941
 942   if (DIEString *S = dyn_cast_or_null<DIEString>(V))
 943     return S->getString();
 944
 945   return StringRef("");
 946 }
 947
 948 /// Return true if the current DIE is contained within an anonymous namespace.
 949 static bool isContainedInAnonNamespace(DIE *Die) {
 950   DIE *Parent = Die->getParent();
 951
 952   while (Parent) {
 953     if (Parent->getTag() == dwarf::DW_TAG_namespace &&
 954         getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
 955       return true;
 956     Parent = Parent->getParent();
 957   }
 958
 959   return false;
 960 }
 961
 962 /// Test if the current CU language is C++ and that we have
 963 /// a named type that is not contained in an anonymous namespace.
 964 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
 965   return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
 966          getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
 967          !isContainedInAnonNamespace(Die);
 968 }
 969
 970 void DwarfDebug::finalizeModuleInfo() {
 971   // Collect info for variables that were optimized out.
 972   collectDeadVariables();
 973
 974   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 975   computeInlinedDIEs();
 976
 977   // Split out type units and conditionally add an ODR tag to the split
 978   // out type.
 979   // FIXME: Do type splitting.
 980   for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
 981     DIE *Die = TypeUnits[i];
 982     DIEHash Hash;
 983     // If we've requested ODR hashes and it's applicable for an ODR hash then
 984     // add the ODR signature now.
 985     // FIXME: This should be added onto the type unit, not the type, but this
 986     // works as an intermediate stage.
 987     if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
 988       CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
 989                                      dwarf::DW_FORM_data8,
 990                                      Hash.computeDIEODRSignature(Die));
 991   }
 992
 993   // Handle anything that needs to be done on a per-cu basis.
 994   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 995                                                          CUE = CUMap.end();
 996        CUI != CUE; ++CUI) {
 997     CompileUnit *TheCU = CUI->second;
 998     // Emit DW_AT_containing_type attribute to connect types with their
 999     // vtable holding type.
1000     TheCU->constructContainingTypeDIEs();
1001
1002     // If we're splitting the dwarf out now that we've got the entire
1003     // CU then construct a skeleton CU based upon it.
1004     if (useSplitDwarf()) {
1005       uint64_t ID = 0;
1006       if (GenerateCUHash) {
1007         DIEHash CUHash;
1008         ID = CUHash.computeCUSignature(TheCU->getCUDie());
1009       }
1010       // This should be a unique identifier when we want to build .dwp files.
1011       TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1012                      dwarf::DW_FORM_data8, ID);
1013       // Now construct the skeleton CU associated.
1014       CompileUnit *SkCU = constructSkeletonCU(TheCU);
1015       // This should be a unique identifier when we want to build .dwp files.
1016       SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1017                     dwarf::DW_FORM_data8, ID);
1018     }
1019   }
1020
1021   // Compute DIE offsets and sizes.
1022   InfoHolder.computeSizeAndOffsets();
1023   if (useSplitDwarf())
1024     SkeletonHolder.computeSizeAndOffsets();
1025 }
1026
1027 void DwarfDebug::endSections() {
1028   // Standard sections final addresses.
1029   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1030   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1031   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1032   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1033
1034   // End text sections.
1035   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1036     Asm->OutStreamer.SwitchSection(SectionMap[I]);
1037     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1038   }
1039 }
1040
1041 // Emit all Dwarf sections that should come after the content.
1042 void DwarfDebug::endModule() {
1043
1044   if (!FirstCU) return;
1045
1046   // End any existing sections.
1047   // TODO: Does this need to happen?
1048   endSections();
1049
1050   // Finalize the debug info for the module.
1051   finalizeModuleInfo();
1052
1053   if (!useSplitDwarf()) {
1054     // Emit all the DIEs into a debug info section.
1055     emitDebugInfo();
1056
1057     // Corresponding abbreviations into a abbrev section.
1058     emitAbbreviations();
1059
1060     // Emit info into a debug loc section.
1061     emitDebugLoc();
1062
1063     // Emit info into a debug aranges section.
1064     emitDebugARanges();
1065
1066     // Emit info into a debug ranges section.
1067     emitDebugRanges();
1068
1069     // Emit info into a debug macinfo section.
1070     emitDebugMacInfo();
1071
1072   } else {
1073     // TODO: Fill this in for separated debug sections and separate
1074     // out information into new sections.
1075
1076     // Emit the debug info section and compile units.
1077     emitDebugInfo();
1078     emitDebugInfoDWO();
1079
1080     // Corresponding abbreviations into a abbrev section.
1081     emitAbbreviations();
1082     emitDebugAbbrevDWO();
1083
1084     // Emit info into a debug loc section.
1085     emitDebugLoc();
1086
1087     // Emit info into a debug aranges section.
1088     emitDebugARanges();
1089
1090     // Emit info into a debug ranges section.
1091     emitDebugRanges();
1092
1093     // Emit info into a debug macinfo section.
1094     emitDebugMacInfo();
1095
1096     // Emit DWO addresses.
1097     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1098
1099   }
1100
1101   // Emit info into the dwarf accelerator table sections.
1102   if (useDwarfAccelTables()) {
1103     emitAccelNames();
1104     emitAccelObjC();
1105     emitAccelNamespaces();
1106     emitAccelTypes();
1107   }
1108
1109   // Emit the pubnames and pubtypes sections if requested.
1110   if (HasDwarfPubSections) {
1111     emitDebugPubNames();
1112     emitDebugPubTypes();
1113   }
1114
1115   // Finally emit string information into a string table.
1116   emitDebugStr();
1117   if (useSplitDwarf())
1118     emitDebugStrDWO();
1119
1120   // clean up.
1121   SPMap.clear();
1122   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1123          E = CUMap.end(); I != E; ++I)
1124     delete I->second;
1125
1126   for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1127          E = SkeletonCUs.end(); I != E; ++I)
1128     delete *I;
1129
1130   // Reset these for the next Module if we have one.
1131   FirstCU = NULL;
1132 }
1133
1134 // Find abstract variable, if any, associated with Var.
1135 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1136                                               DebugLoc ScopeLoc) {
1137   LLVMContext &Ctx = DV->getContext();
1138   // More then one inlined variable corresponds to one abstract variable.
1139   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1140   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1141   if (AbsDbgVariable)
1142     return AbsDbgVariable;
1143
1144   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1145   if (!Scope)
1146     return NULL;
1147
1148   AbsDbgVariable = new DbgVariable(Var, NULL);
1149   addScopeVariable(Scope, AbsDbgVariable);
1150   AbstractVariables[Var] = AbsDbgVariable;
1151   return AbsDbgVariable;
1152 }
1153
1154 // If Var is a current function argument then add it to CurrentFnArguments list.
1155 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1156                                       DbgVariable *Var, LexicalScope *Scope) {
1157   if (!LScopes.isCurrentFunctionScope(Scope))
1158     return false;
1159   DIVariable DV = Var->getVariable();
1160   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1161     return false;
1162   unsigned ArgNo = DV.getArgNumber();
1163   if (ArgNo == 0)
1164     return false;
1165
1166   size_t Size = CurrentFnArguments.size();
1167   if (Size == 0)
1168     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1169   // llvm::Function argument size is not good indicator of how many
1170   // arguments does the function have at source level.
1171   if (ArgNo > Size)
1172     CurrentFnArguments.resize(ArgNo * 2);
1173   CurrentFnArguments[ArgNo - 1] = Var;
1174   return true;
1175 }
1176
1177 // Collect variable information from side table maintained by MMI.
1178 void
1179 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1180                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1181   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1182   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1183          VE = VMap.end(); VI != VE; ++VI) {
1184     const MDNode *Var = VI->first;
1185     if (!Var) continue;
1186     Processed.insert(Var);
1187     DIVariable DV(Var);
1188     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1189
1190     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1191
1192     // If variable scope is not found then skip this variable.
1193     if (Scope == 0)
1194       continue;
1195
1196     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1197     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1198     RegVar->setFrameIndex(VP.first);
1199     if (!addCurrentFnArgument(MF, RegVar, Scope))
1200       addScopeVariable(Scope, RegVar);
1201     if (AbsDbgVariable)
1202       AbsDbgVariable->setFrameIndex(VP.first);
1203   }
1204 }
1205
1206 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1207 // defined reg.
1208 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1209   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1210   return MI->getNumOperands() == 3 &&
1211          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1212          (MI->getOperand(1).isImm() ||
1213           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1214 }
1215
1216 // Get .debug_loc entry for the instruction range starting at MI.
1217 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1218                                          const MCSymbol *FLabel,
1219                                          const MCSymbol *SLabel,
1220                                          const MachineInstr *MI) {
1221   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1222
1223   assert(MI->getNumOperands() == 3);
1224   if (MI->getOperand(0).isReg()) {
1225     MachineLocation MLoc;
1226     // If the second operand is an immediate, this is a
1227     // register-indirect address.
1228     if (!MI->getOperand(1).isImm())
1229       MLoc.set(MI->getOperand(0).getReg());
1230     else
1231       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1232     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1233   }
1234   if (MI->getOperand(0).isImm())
1235     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1236   if (MI->getOperand(0).isFPImm())
1237     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1238   if (MI->getOperand(0).isCImm())
1239     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1240
1241   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1242 }
1243
1244 // Find variables for each lexical scope.
1245 void
1246 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1247                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1248
1249   // Grab the variable info that was squirreled away in the MMI side-table.
1250   collectVariableInfoFromMMITable(MF, Processed);
1251
1252   for (SmallVectorImpl<const MDNode*>::const_iterator
1253          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1254          ++UVI) {
1255     const MDNode *Var = *UVI;
1256     if (Processed.count(Var))
1257       continue;
1258
1259     // History contains relevant DBG_VALUE instructions for Var and instructions
1260     // clobbering it.
1261     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1262     if (History.empty())
1263       continue;
1264     const MachineInstr *MInsn = History.front();
1265
1266     DIVariable DV(Var);
1267     LexicalScope *Scope = NULL;
1268     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1269         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1270       Scope = LScopes.getCurrentFunctionScope();
1271     else if (MDNode *IA = DV.getInlinedAt())
1272       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1273     else
1274       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1275     // If variable scope is not found then skip this variable.
1276     if (!Scope)
1277       continue;
1278
1279     Processed.insert(DV);
1280     assert(MInsn->isDebugValue() && "History must begin with debug value");
1281     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1282     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1283     if (!addCurrentFnArgument(MF, RegVar, Scope))
1284       addScopeVariable(Scope, RegVar);
1285     if (AbsVar)
1286       AbsVar->setMInsn(MInsn);
1287
1288     // Simplify ranges that are fully coalesced.
1289     if (History.size() <= 1 || (History.size() == 2 &&
1290                                 MInsn->isIdenticalTo(History.back()))) {
1291       RegVar->setMInsn(MInsn);
1292       continue;
1293     }
1294
1295     // Handle multiple DBG_VALUE instructions describing one variable.
1296     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1297
1298     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1299            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1300       const MachineInstr *Begin = *HI;
1301       assert(Begin->isDebugValue() && "Invalid History entry");
1302
1303       // Check if DBG_VALUE is truncating a range.
1304       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1305           && !Begin->getOperand(0).getReg())
1306         continue;
1307
1308       // Compute the range for a register location.
1309       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1310       const MCSymbol *SLabel = 0;
1311
1312       if (HI + 1 == HE)
1313         // If Begin is the last instruction in History then its value is valid
1314         // until the end of the function.
1315         SLabel = FunctionEndSym;
1316       else {
1317         const MachineInstr *End = HI[1];
1318         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1319               << "\t" << *Begin << "\t" << *End << "\n");
1320         if (End->isDebugValue())
1321           SLabel = getLabelBeforeInsn(End);
1322         else {
1323           // End is a normal instruction clobbering the range.
1324           SLabel = getLabelAfterInsn(End);
1325           assert(SLabel && "Forgot label after clobber instruction");
1326           ++HI;
1327         }
1328       }
1329
1330       // The value is valid until the next DBG_VALUE or clobber.
1331       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1332                                                     Begin));
1333     }
1334     DotDebugLocEntries.push_back(DotDebugLocEntry());
1335   }
1336
1337   // Collect info for variables that were optimized out.
1338   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1339   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1340   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1341     DIVariable DV(Variables.getElement(i));
1342     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1343       continue;
1344     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1345       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1346   }
1347 }
1348
1349 // Return Label preceding the instruction.
1350 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1351   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1352   assert(Label && "Didn't insert label before instruction");
1353   return Label;
1354 }
1355
1356 // Return Label immediately following the instruction.
1357 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1358   return LabelsAfterInsn.lookup(MI);
1359 }
1360
1361 // Process beginning of an instruction.
1362 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1363   // Check if source location changes, but ignore DBG_VALUE locations.
1364   if (!MI->isDebugValue()) {
1365     DebugLoc DL = MI->getDebugLoc();
1366     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1367       unsigned Flags = 0;
1368       PrevInstLoc = DL;
1369       if (DL == PrologEndLoc) {
1370         Flags |= DWARF2_FLAG_PROLOGUE_END;
1371         PrologEndLoc = DebugLoc();
1372       }
1373       if (PrologEndLoc.isUnknown())
1374         Flags |= DWARF2_FLAG_IS_STMT;
1375
1376       if (!DL.isUnknown()) {
1377         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1378         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1379       } else
1380         recordSourceLine(0, 0, 0, 0);
1381     }
1382   }
1383
1384   // Insert labels where requested.
1385   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1386     LabelsBeforeInsn.find(MI);
1387
1388   // No label needed.
1389   if (I == LabelsBeforeInsn.end())
1390     return;
1391
1392   // Label already assigned.
1393   if (I->second)
1394     return;
1395
1396   if (!PrevLabel) {
1397     PrevLabel = MMI->getContext().CreateTempSymbol();
1398     Asm->OutStreamer.EmitLabel(PrevLabel);
1399   }
1400   I->second = PrevLabel;
1401 }
1402
1403 // Process end of an instruction.
1404 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1405   // Don't create a new label after DBG_VALUE instructions.
1406   // They don't generate code.
1407   if (!MI->isDebugValue())
1408     PrevLabel = 0;
1409
1410   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1411     LabelsAfterInsn.find(MI);
1412
1413   // No label needed.
1414   if (I == LabelsAfterInsn.end())
1415     return;
1416
1417   // Label already assigned.
1418   if (I->second)
1419     return;
1420
1421   // We need a label after this instruction.
1422   if (!PrevLabel) {
1423     PrevLabel = MMI->getContext().CreateTempSymbol();
1424     Asm->OutStreamer.EmitLabel(PrevLabel);
1425   }
1426   I->second = PrevLabel;
1427 }
1428
1429 // Each LexicalScope has first instruction and last instruction to mark
1430 // beginning and end of a scope respectively. Create an inverse map that list
1431 // scopes starts (and ends) with an instruction. One instruction may start (or
1432 // end) multiple scopes. Ignore scopes that are not reachable.
1433 void DwarfDebug::identifyScopeMarkers() {
1434   SmallVector<LexicalScope *, 4> WorkList;
1435   WorkList.push_back(LScopes.getCurrentFunctionScope());
1436   while (!WorkList.empty()) {
1437     LexicalScope *S = WorkList.pop_back_val();
1438
1439     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1440     if (!Children.empty())
1441       for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1442              SE = Children.end(); SI != SE; ++SI)
1443         WorkList.push_back(*SI);
1444
1445     if (S->isAbstractScope())
1446       continue;
1447
1448     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1449     if (Ranges.empty())
1450       continue;
1451     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1452            RE = Ranges.end(); RI != RE; ++RI) {
1453       assert(RI->first && "InsnRange does not have first instruction!");
1454       assert(RI->second && "InsnRange does not have second instruction!");
1455       requestLabelBeforeInsn(RI->first);
1456       requestLabelAfterInsn(RI->second);
1457     }
1458   }
1459 }
1460
1461 // Get MDNode for DebugLoc's scope.
1462 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1463   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1464     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1465   return DL.getScope(Ctx);
1466 }
1467
1468 // Walk up the scope chain of given debug loc and find line number info
1469 // for the function.
1470 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1471   const MDNode *Scope = getScopeNode(DL, Ctx);
1472   DISubprogram SP = getDISubprogram(Scope);
1473   if (SP.isSubprogram()) {
1474     // Check for number of operands since the compatibility is
1475     // cheap here.
1476     if (SP->getNumOperands() > 19)
1477       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1478     else
1479       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1480   }
1481
1482   return DebugLoc();
1483 }
1484
1485 // Gather pre-function debug information.  Assumes being called immediately
1486 // after the function entry point has been emitted.
1487 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1488   if (!MMI->hasDebugInfo()) return;
1489   LScopes.initialize(*MF);
1490   if (LScopes.empty()) return;
1491   identifyScopeMarkers();
1492
1493   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1494   // belongs to.
1495   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1496   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1497   assert(TheCU && "Unable to find compile unit!");
1498   if (Asm->TM.hasMCUseLoc() &&
1499       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1500     // Use a single line table if we are using .loc and generating assembly.
1501     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1502   else
1503     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1504
1505   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1506                                         Asm->getFunctionNumber());
1507   // Assumes in correct section after the entry point.
1508   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1509
1510   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1511
1512   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1513   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1514   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1515
1516   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1517        I != E; ++I) {
1518     bool AtBlockEntry = true;
1519     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1520          II != IE; ++II) {
1521       const MachineInstr *MI = II;
1522
1523       if (MI->isDebugValue()) {
1524         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1525
1526         // Keep track of user variables.
1527         const MDNode *Var =
1528           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1529
1530         // Variable is in a register, we need to check for clobbers.
1531         if (isDbgValueInDefinedReg(MI))
1532           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1533
1534         // Check the history of this variable.
1535         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1536         if (History.empty()) {
1537           UserVariables.push_back(Var);
1538           // The first mention of a function argument gets the FunctionBeginSym
1539           // label, so arguments are visible when breaking at function entry.
1540           DIVariable DV(Var);
1541           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1542               DISubprogram(getDISubprogram(DV.getContext()))
1543                 .describes(MF->getFunction()))
1544             LabelsBeforeInsn[MI] = FunctionBeginSym;
1545         } else {
1546           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1547           const MachineInstr *Prev = History.back();
1548           if (Prev->isDebugValue()) {
1549             // Coalesce identical entries at the end of History.
1550             if (History.size() >= 2 &&
1551                 Prev->isIdenticalTo(History[History.size() - 2])) {
1552               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1553                     << "\t" << *Prev
1554                     << "\t" << *History[History.size() - 2] << "\n");
1555               History.pop_back();
1556             }
1557
1558             // Terminate old register assignments that don't reach MI;
1559             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1560             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1561                 isDbgValueInDefinedReg(Prev)) {
1562               // Previous register assignment needs to terminate at the end of
1563               // its basic block.
1564               MachineBasicBlock::const_iterator LastMI =
1565                 PrevMBB->getLastNonDebugInstr();
1566               if (LastMI == PrevMBB->end()) {
1567                 // Drop DBG_VALUE for empty range.
1568                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1569                       << "\t" << *Prev << "\n");
1570                 History.pop_back();
1571               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1572                 // Terminate after LastMI.
1573                 History.push_back(LastMI);
1574             }
1575           }
1576         }
1577         History.push_back(MI);
1578       } else {
1579         // Not a DBG_VALUE instruction.
1580         if (!MI->isLabel())
1581           AtBlockEntry = false;
1582
1583         // First known non-DBG_VALUE and non-frame setup location marks
1584         // the beginning of the function body.
1585         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1586             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1587           PrologEndLoc = MI->getDebugLoc();
1588
1589         // Check if the instruction clobbers any registers with debug vars.
1590         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1591                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1592           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1593             continue;
1594           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1595                AI.isValid(); ++AI) {
1596             unsigned Reg = *AI;
1597             const MDNode *Var = LiveUserVar[Reg];
1598             if (!Var)
1599               continue;
1600             // Reg is now clobbered.
1601             LiveUserVar[Reg] = 0;
1602
1603             // Was MD last defined by a DBG_VALUE referring to Reg?
1604             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1605             if (HistI == DbgValues.end())
1606               continue;
1607             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1608             if (History.empty())
1609               continue;
1610             const MachineInstr *Prev = History.back();
1611             // Sanity-check: Register assignments are terminated at the end of
1612             // their block.
1613             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1614               continue;
1615             // Is the variable still in Reg?
1616             if (!isDbgValueInDefinedReg(Prev) ||
1617                 Prev->getOperand(0).getReg() != Reg)
1618               continue;
1619             // Var is clobbered. Make sure the next instruction gets a label.
1620             History.push_back(MI);
1621           }
1622         }
1623       }
1624     }
1625   }
1626
1627   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1628        I != E; ++I) {
1629     SmallVectorImpl<const MachineInstr*> &History = I->second;
1630     if (History.empty())
1631       continue;
1632
1633     // Make sure the final register assignments are terminated.
1634     const MachineInstr *Prev = History.back();
1635     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1636       const MachineBasicBlock *PrevMBB = Prev->getParent();
1637       MachineBasicBlock::const_iterator LastMI =
1638         PrevMBB->getLastNonDebugInstr();
1639       if (LastMI == PrevMBB->end())
1640         // Drop DBG_VALUE for empty range.
1641         History.pop_back();
1642       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1643         // Terminate after LastMI.
1644         History.push_back(LastMI);
1645       }
1646     }
1647     // Request labels for the full history.
1648     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1649       const MachineInstr *MI = History[i];
1650       if (MI->isDebugValue())
1651         requestLabelBeforeInsn(MI);
1652       else
1653         requestLabelAfterInsn(MI);
1654     }
1655   }
1656
1657   PrevInstLoc = DebugLoc();
1658   PrevLabel = FunctionBeginSym;
1659
1660   // Record beginning of function.
1661   if (!PrologEndLoc.isUnknown()) {
1662     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1663                                        MF->getFunction()->getContext());
1664     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1665                      FnStartDL.getScope(MF->getFunction()->getContext()),
1666     // We'd like to list the prologue as "not statements" but GDB behaves
1667     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1668                      DWARF2_FLAG_IS_STMT);
1669   }
1670 }
1671
1672 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1673   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1674   DIVariable DV = Var->getVariable();
1675   // Variables with positive arg numbers are parameters.
1676   if (unsigned ArgNum = DV.getArgNumber()) {
1677     // Keep all parameters in order at the start of the variable list to ensure
1678     // function types are correct (no out-of-order parameters)
1679     //
1680     // This could be improved by only doing it for optimized builds (unoptimized
1681     // builds have the right order to begin with), searching from the back (this
1682     // would catch the unoptimized case quickly), or doing a binary search
1683     // rather than linear search.
1684     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1685     while (I != Vars.end()) {
1686       unsigned CurNum = (*I)->getVariable().getArgNumber();
1687       // A local (non-parameter) variable has been found, insert immediately
1688       // before it.
1689       if (CurNum == 0)
1690         break;
1691       // A later indexed parameter has been found, insert immediately before it.
1692       if (CurNum > ArgNum)
1693         break;
1694       ++I;
1695     }
1696     Vars.insert(I, Var);
1697     return;
1698   }
1699
1700   Vars.push_back(Var);
1701 }
1702
1703 // Gather and emit post-function debug information.
1704 void DwarfDebug::endFunction(const MachineFunction *MF) {
1705   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1706
1707   // Define end label for subprogram.
1708   FunctionEndSym = Asm->GetTempSymbol("func_end",
1709                                       Asm->getFunctionNumber());
1710   // Assumes in correct section after the entry point.
1711   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1712   // Set DwarfCompileUnitID in MCContext to default value.
1713   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1714
1715   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1716   collectVariableInfo(MF, ProcessedVars);
1717
1718   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1719   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1720   assert(TheCU && "Unable to find compile unit!");
1721
1722   // Construct abstract scopes.
1723   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1724   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1725     LexicalScope *AScope = AList[i];
1726     DISubprogram SP(AScope->getScopeNode());
1727     if (SP.isSubprogram()) {
1728       // Collect info for variables that were optimized out.
1729       DIArray Variables = SP.getVariables();
1730       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1731         DIVariable DV(Variables.getElement(i));
1732         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1733           continue;
1734         // Check that DbgVariable for DV wasn't created earlier, when
1735         // findAbstractVariable() was called for inlined instance of DV.
1736         LLVMContext &Ctx = DV->getContext();
1737         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1738         if (AbstractVariables.lookup(CleanDV))
1739           continue;
1740         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1741           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1742       }
1743     }
1744     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1745       constructScopeDIE(TheCU, AScope);
1746   }
1747
1748   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1749
1750   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1751     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1752
1753   // Clear debug info
1754   for (ScopeVariablesMap::iterator
1755          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1756     DeleteContainerPointers(I->second);
1757   ScopeVariables.clear();
1758   DeleteContainerPointers(CurrentFnArguments);
1759   UserVariables.clear();
1760   DbgValues.clear();
1761   AbstractVariables.clear();
1762   LabelsBeforeInsn.clear();
1763   LabelsAfterInsn.clear();
1764   PrevLabel = NULL;
1765 }
1766
1767 // Register a source line with debug info. Returns the  unique label that was
1768 // emitted and which provides correspondence to the source line list.
1769 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1770                                   unsigned Flags) {
1771   StringRef Fn;
1772   StringRef Dir;
1773   unsigned Src = 1;
1774   if (S) {
1775     DIDescriptor Scope(S);
1776
1777     if (Scope.isCompileUnit()) {
1778       DICompileUnit CU(S);
1779       Fn = CU.getFilename();
1780       Dir = CU.getDirectory();
1781     } else if (Scope.isFile()) {
1782       DIFile F(S);
1783       Fn = F.getFilename();
1784       Dir = F.getDirectory();
1785     } else if (Scope.isSubprogram()) {
1786       DISubprogram SP(S);
1787       Fn = SP.getFilename();
1788       Dir = SP.getDirectory();
1789     } else if (Scope.isLexicalBlockFile()) {
1790       DILexicalBlockFile DBF(S);
1791       Fn = DBF.getFilename();
1792       Dir = DBF.getDirectory();
1793     } else if (Scope.isLexicalBlock()) {
1794       DILexicalBlock DB(S);
1795       Fn = DB.getFilename();
1796       Dir = DB.getDirectory();
1797     } else
1798       llvm_unreachable("Unexpected scope info");
1799
1800     Src = getOrCreateSourceID(Fn, Dir,
1801             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1802   }
1803   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1804 }
1805
1806 //===----------------------------------------------------------------------===//
1807 // Emit Methods
1808 //===----------------------------------------------------------------------===//
1809
1810 // Compute the size and offset of a DIE.
1811 unsigned
1812 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1813   // Get the children.
1814   const std::vector<DIE *> &Children = Die->getChildren();
1815
1816   // Record the abbreviation.
1817   assignAbbrevNumber(Die->getAbbrev());
1818
1819   // Get the abbreviation for this DIE.
1820   unsigned AbbrevNumber = Die->getAbbrevNumber();
1821   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1822
1823   // Set DIE offset
1824   Die->setOffset(Offset);
1825
1826   // Start the size with the size of abbreviation code.
1827   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1828
1829   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1830   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1831
1832   // Size the DIE attribute values.
1833   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1834     // Size attribute value.
1835     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1836
1837   // Size the DIE children if any.
1838   if (!Children.empty()) {
1839     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1840            "Children flag not set");
1841
1842     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1843       Offset = computeSizeAndOffset(Children[j], Offset);
1844
1845     // End of children marker.
1846     Offset += sizeof(int8_t);
1847   }
1848
1849   Die->setSize(Offset - Die->getOffset());
1850   return Offset;
1851 }
1852
1853 // Compute the size and offset of all the DIEs.
1854 void DwarfUnits::computeSizeAndOffsets() {
1855   // Offset from the beginning of debug info section.
1856   unsigned SecOffset = 0;
1857   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1858          E = CUs.end(); I != E; ++I) {
1859     (*I)->setDebugInfoOffset(SecOffset);
1860     unsigned Offset =
1861       sizeof(int32_t) + // Length of Compilation Unit Info
1862       sizeof(int16_t) + // DWARF version number
1863       sizeof(int32_t) + // Offset Into Abbrev. Section
1864       sizeof(int8_t);   // Pointer Size (in bytes)
1865
1866     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1867     SecOffset += EndOffset;
1868   }
1869 }
1870
1871 // Emit initial Dwarf sections with a label at the start of each one.
1872 void DwarfDebug::emitSectionLabels() {
1873   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1874
1875   // Dwarf sections base addresses.
1876   DwarfInfoSectionSym =
1877     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1878   DwarfAbbrevSectionSym =
1879     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1880   if (useSplitDwarf())
1881     DwarfAbbrevDWOSectionSym =
1882       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1883                      "section_abbrev_dwo");
1884   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1885
1886   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1887     emitSectionSym(Asm, MacroInfo);
1888
1889   DwarfLineSectionSym =
1890     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1891   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1892   if (HasDwarfPubSections) {
1893     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1894     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1895   }
1896   DwarfStrSectionSym =
1897     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1898   if (useSplitDwarf()) {
1899     DwarfStrDWOSectionSym =
1900       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1901     DwarfAddrSectionSym =
1902       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1903   }
1904   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1905                                              "debug_range");
1906
1907   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1908                                            "section_debug_loc");
1909
1910   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1911   emitSectionSym(Asm, TLOF.getDataSection());
1912 }
1913
1914 // Recursively emits a debug information entry.
1915 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1916   // Get the abbreviation for this DIE.
1917   unsigned AbbrevNumber = Die->getAbbrevNumber();
1918   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1919
1920   // Emit the code (index) for the abbreviation.
1921   if (Asm->isVerbose())
1922     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1923                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1924                                 Twine::utohexstr(Die->getSize()) + " " +
1925                                 dwarf::TagString(Abbrev->getTag()));
1926   Asm->EmitULEB128(AbbrevNumber);
1927
1928   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1929   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1930
1931   // Emit the DIE attribute values.
1932   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1933     unsigned Attr = AbbrevData[i].getAttribute();
1934     unsigned Form = AbbrevData[i].getForm();
1935     assert(Form && "Too many attributes for DIE (check abbreviation)");
1936
1937     if (Asm->isVerbose())
1938       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1939
1940     switch (Attr) {
1941     case dwarf::DW_AT_abstract_origin: {
1942       DIEEntry *E = cast<DIEEntry>(Values[i]);
1943       DIE *Origin = E->getEntry();
1944       unsigned Addr = Origin->getOffset();
1945       if (Form == dwarf::DW_FORM_ref_addr) {
1946         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1947         // section. Origin->getOffset() returns the offset from start of the
1948         // compile unit.
1949         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1950         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1951       }
1952       Asm->OutStreamer.EmitIntValue(Addr,
1953           Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1954       break;
1955     }
1956     case dwarf::DW_AT_ranges: {
1957       // DW_AT_range Value encodes offset in debug_range section.
1958       DIEInteger *V = cast<DIEInteger>(Values[i]);
1959
1960       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1961         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1962                                  V->getValue(),
1963                                  4);
1964       } else {
1965         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1966                                        V->getValue(),
1967                                        DwarfDebugRangeSectionSym,
1968                                        4);
1969       }
1970       break;
1971     }
1972     case dwarf::DW_AT_location: {
1973       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1974         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1975           Asm->EmitLabelReference(L->getValue(), 4);
1976         else
1977           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1978       } else {
1979         Values[i]->EmitValue(Asm, Form);
1980       }
1981       break;
1982     }
1983     case dwarf::DW_AT_accessibility: {
1984       if (Asm->isVerbose()) {
1985         DIEInteger *V = cast<DIEInteger>(Values[i]);
1986         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1987       }
1988       Values[i]->EmitValue(Asm, Form);
1989       break;
1990     }
1991     default:
1992       // Emit an attribute using the defined form.
1993       Values[i]->EmitValue(Asm, Form);
1994       break;
1995     }
1996   }
1997
1998   // Emit the DIE children if any.
1999   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2000     const std::vector<DIE *> &Children = Die->getChildren();
2001
2002     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2003       emitDIE(Children[j], Abbrevs);
2004
2005     if (Asm->isVerbose())
2006       Asm->OutStreamer.AddComment("End Of Children Mark");
2007     Asm->EmitInt8(0);
2008   }
2009 }
2010
2011 // Emit the various dwarf units to the unit section USection with
2012 // the abbreviations going into ASection.
2013 void DwarfUnits::emitUnits(DwarfDebug *DD,
2014                            const MCSection *USection,
2015                            const MCSection *ASection,
2016                            const MCSymbol *ASectionSym) {
2017   Asm->OutStreamer.SwitchSection(USection);
2018   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2019          E = CUs.end(); I != E; ++I) {
2020     CompileUnit *TheCU = *I;
2021     DIE *Die = TheCU->getCUDie();
2022
2023     // Emit the compile units header.
2024     Asm->OutStreamer
2025       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2026                                     TheCU->getUniqueID()));
2027
2028     // Emit size of content not including length itself
2029     unsigned ContentSize = Die->getSize() +
2030       sizeof(int16_t) + // DWARF version number
2031       sizeof(int32_t) + // Offset Into Abbrev. Section
2032       sizeof(int8_t);   // Pointer Size (in bytes)
2033
2034     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2035     Asm->EmitInt32(ContentSize);
2036     Asm->OutStreamer.AddComment("DWARF version number");
2037     Asm->EmitInt16(DD->getDwarfVersion());
2038     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2039     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2040                            ASectionSym);
2041     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2042     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2043
2044     DD->emitDIE(Die, Abbreviations);
2045     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2046                                                   TheCU->getUniqueID()));
2047   }
2048 }
2049
2050 /// For a given compile unit DIE, returns offset from beginning of debug info.
2051 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2052   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
2053          "Input DIE should be compile unit in getCUOffset.");
2054   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2055        I != E; ++I) {
2056     CompileUnit *TheCU = *I;
2057     if (TheCU->getCUDie() == Die)
2058       return TheCU->getDebugInfoOffset();
2059   }
2060   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2061 }
2062
2063 // Emit the debug info section.
2064 void DwarfDebug::emitDebugInfo() {
2065   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2066
2067   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2068                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2069                    DwarfAbbrevSectionSym);
2070 }
2071
2072 // Emit the abbreviation section.
2073 void DwarfDebug::emitAbbreviations() {
2074   if (!useSplitDwarf())
2075     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2076                 &Abbreviations);
2077   else
2078     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2079 }
2080
2081 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2082                              std::vector<DIEAbbrev *> *Abbrevs) {
2083   // Check to see if it is worth the effort.
2084   if (!Abbrevs->empty()) {
2085     // Start the debug abbrev section.
2086     Asm->OutStreamer.SwitchSection(Section);
2087
2088     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2089     Asm->OutStreamer.EmitLabel(Begin);
2090
2091     // For each abbrevation.
2092     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2093       // Get abbreviation data
2094       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2095
2096       // Emit the abbrevations code (base 1 index.)
2097       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2098
2099       // Emit the abbreviations data.
2100       Abbrev->Emit(Asm);
2101     }
2102
2103     // Mark end of abbreviations.
2104     Asm->EmitULEB128(0, "EOM(3)");
2105
2106     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2107     Asm->OutStreamer.EmitLabel(End);
2108   }
2109 }
2110
2111 // Emit the last address of the section and the end of the line matrix.
2112 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2113   // Define last address of section.
2114   Asm->OutStreamer.AddComment("Extended Op");
2115   Asm->EmitInt8(0);
2116
2117   Asm->OutStreamer.AddComment("Op size");
2118   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2119   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2120   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2121
2122   Asm->OutStreamer.AddComment("Section end label");
2123
2124   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2125                                    Asm->getDataLayout().getPointerSize());
2126
2127   // Mark end of matrix.
2128   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2129   Asm->EmitInt8(0);
2130   Asm->EmitInt8(1);
2131   Asm->EmitInt8(1);
2132 }
2133
2134 // Emit visible names into a hashed accelerator table section.
2135 void DwarfDebug::emitAccelNames() {
2136   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2137                                            dwarf::DW_FORM_data4));
2138   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2139          E = CUMap.end(); I != E; ++I) {
2140     CompileUnit *TheCU = I->second;
2141     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2142     for (StringMap<std::vector<DIE*> >::const_iterator
2143            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2144       StringRef Name = GI->getKey();
2145       const std::vector<DIE *> &Entities = GI->second;
2146       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2147              DE = Entities.end(); DI != DE; ++DI)
2148         AT.AddName(Name, (*DI));
2149     }
2150   }
2151
2152   AT.FinalizeTable(Asm, "Names");
2153   Asm->OutStreamer.SwitchSection(
2154     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2155   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2156   Asm->OutStreamer.EmitLabel(SectionBegin);
2157
2158   // Emit the full data.
2159   AT.Emit(Asm, SectionBegin, &InfoHolder);
2160 }
2161
2162 // Emit objective C classes and categories into a hashed accelerator table
2163 // section.
2164 void DwarfDebug::emitAccelObjC() {
2165   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2166                                            dwarf::DW_FORM_data4));
2167   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2168          E = CUMap.end(); I != E; ++I) {
2169     CompileUnit *TheCU = I->second;
2170     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2171     for (StringMap<std::vector<DIE*> >::const_iterator
2172            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2173       StringRef Name = GI->getKey();
2174       const std::vector<DIE *> &Entities = GI->second;
2175       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2176              DE = Entities.end(); DI != DE; ++DI)
2177         AT.AddName(Name, (*DI));
2178     }
2179   }
2180
2181   AT.FinalizeTable(Asm, "ObjC");
2182   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2183                                  .getDwarfAccelObjCSection());
2184   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2185   Asm->OutStreamer.EmitLabel(SectionBegin);
2186
2187   // Emit the full data.
2188   AT.Emit(Asm, SectionBegin, &InfoHolder);
2189 }
2190
2191 // Emit namespace dies into a hashed accelerator table.
2192 void DwarfDebug::emitAccelNamespaces() {
2193   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2194                                            dwarf::DW_FORM_data4));
2195   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2196          E = CUMap.end(); I != E; ++I) {
2197     CompileUnit *TheCU = I->second;
2198     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2199     for (StringMap<std::vector<DIE*> >::const_iterator
2200            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2201       StringRef Name = GI->getKey();
2202       const std::vector<DIE *> &Entities = GI->second;
2203       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2204              DE = Entities.end(); DI != DE; ++DI)
2205         AT.AddName(Name, (*DI));
2206     }
2207   }
2208
2209   AT.FinalizeTable(Asm, "namespac");
2210   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2211                                  .getDwarfAccelNamespaceSection());
2212   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2213   Asm->OutStreamer.EmitLabel(SectionBegin);
2214
2215   // Emit the full data.
2216   AT.Emit(Asm, SectionBegin, &InfoHolder);
2217 }
2218
2219 // Emit type dies into a hashed accelerator table.
2220 void DwarfDebug::emitAccelTypes() {
2221   std::vector<DwarfAccelTable::Atom> Atoms;
2222   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2223                                         dwarf::DW_FORM_data4));
2224   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2225                                         dwarf::DW_FORM_data2));
2226   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2227                                         dwarf::DW_FORM_data1));
2228   DwarfAccelTable AT(Atoms);
2229   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2230          E = CUMap.end(); I != E; ++I) {
2231     CompileUnit *TheCU = I->second;
2232     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2233       = TheCU->getAccelTypes();
2234     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2235            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2236       StringRef Name = GI->getKey();
2237       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2238       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2239              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2240         AT.AddName(Name, (*DI).first, (*DI).second);
2241     }
2242   }
2243
2244   AT.FinalizeTable(Asm, "types");
2245   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2246                                  .getDwarfAccelTypesSection());
2247   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2248   Asm->OutStreamer.EmitLabel(SectionBegin);
2249
2250   // Emit the full data.
2251   AT.Emit(Asm, SectionBegin, &InfoHolder);
2252 }
2253
2254 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2255 ///
2256 void DwarfDebug::emitDebugPubNames() {
2257   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2258
2259   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2260   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2261     CompileUnit *TheCU = I->second;
2262     unsigned ID = TheCU->getUniqueID();
2263
2264     if (TheCU->getGlobalNames().empty())
2265       continue;
2266
2267     // Start the dwarf pubnames section.
2268     Asm->OutStreamer
2269         .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2270
2271     Asm->OutStreamer.AddComment("Length of Public Names Info");
2272     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2273                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2274
2275     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2276
2277     Asm->OutStreamer.AddComment("DWARF Version");
2278     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2279
2280     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2281     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2282                            DwarfInfoSectionSym);
2283
2284     Asm->OutStreamer.AddComment("Compilation Unit Length");
2285     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2286                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2287                              4);
2288
2289     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2290     for (StringMap<DIE*>::const_iterator
2291            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2292       const char *Name = GI->getKeyData();
2293       const DIE *Entity = GI->second;
2294
2295       Asm->OutStreamer.AddComment("DIE offset");
2296       Asm->EmitInt32(Entity->getOffset());
2297
2298       if (Asm->isVerbose())
2299         Asm->OutStreamer.AddComment("External Name");
2300       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2301     }
2302
2303     Asm->OutStreamer.AddComment("End Mark");
2304     Asm->EmitInt32(0);
2305     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2306   }
2307 }
2308
2309 void DwarfDebug::emitDebugPubTypes() {
2310   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2311          E = CUMap.end(); I != E; ++I) {
2312     CompileUnit *TheCU = I->second;
2313     // Start the dwarf pubtypes section.
2314     Asm->OutStreamer.SwitchSection(
2315       Asm->getObjFileLowering().getDwarfPubTypesSection());
2316     Asm->OutStreamer.AddComment("Length of Public Types Info");
2317     Asm->EmitLabelDifference(
2318       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2319       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2320
2321     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2322                                                   TheCU->getUniqueID()));
2323
2324     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2325     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2326
2327     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2328     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2329     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2330                                               TheCU->getUniqueID()),
2331                            DwarfInfoSectionSym);
2332
2333     Asm->OutStreamer.AddComment("Compilation Unit Length");
2334     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2335                                                 TheCU->getUniqueID()),
2336                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2337                                                 TheCU->getUniqueID()),
2338                              4);
2339
2340     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2341     for (StringMap<DIE*>::const_iterator
2342            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2343       const char *Name = GI->getKeyData();
2344       DIE *Entity = GI->second;
2345
2346       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2347       Asm->EmitInt32(Entity->getOffset());
2348
2349       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2350       // Emit the name with a terminating null byte.
2351       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2352     }
2353
2354     Asm->OutStreamer.AddComment("End Mark");
2355     Asm->EmitInt32(0);
2356     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2357                                                   TheCU->getUniqueID()));
2358   }
2359 }
2360
2361 // Emit strings into a string section.
2362 void DwarfUnits::emitStrings(const MCSection *StrSection,
2363                              const MCSection *OffsetSection = NULL,
2364                              const MCSymbol *StrSecSym = NULL) {
2365
2366   if (StringPool.empty()) return;
2367
2368   // Start the dwarf str section.
2369   Asm->OutStreamer.SwitchSection(StrSection);
2370
2371   // Get all of the string pool entries and put them in an array by their ID so
2372   // we can sort them.
2373   SmallVector<std::pair<unsigned,
2374                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2375
2376   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2377          I = StringPool.begin(), E = StringPool.end();
2378        I != E; ++I)
2379     Entries.push_back(std::make_pair(I->second.second, &*I));
2380
2381   array_pod_sort(Entries.begin(), Entries.end());
2382
2383   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2384     // Emit a label for reference from debug information entries.
2385     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2386
2387     // Emit the string itself with a terminating null byte.
2388     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2389                                          Entries[i].second->getKeyLength()+1));
2390   }
2391
2392   // If we've got an offset section go ahead and emit that now as well.
2393   if (OffsetSection) {
2394     Asm->OutStreamer.SwitchSection(OffsetSection);
2395     unsigned offset = 0;
2396     unsigned size = 4; // FIXME: DWARF64 is 8.
2397     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2398       Asm->OutStreamer.EmitIntValue(offset, size);
2399       offset += Entries[i].second->getKeyLength() + 1;
2400     }
2401   }
2402 }
2403
2404 // Emit strings into a string section.
2405 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2406
2407   if (AddressPool.empty()) return;
2408
2409   // Start the dwarf addr section.
2410   Asm->OutStreamer.SwitchSection(AddrSection);
2411
2412   // Order the address pool entries by ID
2413   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2414
2415   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2416                                                     E = AddressPool.end();
2417        I != E; ++I)
2418     Entries[I->second] = I->first;
2419
2420   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2421     // Emit an expression for reference from debug information entries.
2422     if (const MCExpr *Expr = Entries[i])
2423       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2424     else
2425       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2426   }
2427
2428 }
2429
2430 // Emit visible names into a debug str section.
2431 void DwarfDebug::emitDebugStr() {
2432   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2433   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2434 }
2435
2436 // Emit locations into the debug loc section.
2437 void DwarfDebug::emitDebugLoc() {
2438   if (DotDebugLocEntries.empty())
2439     return;
2440
2441   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2442          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2443        I != E; ++I) {
2444     DotDebugLocEntry &Entry = *I;
2445     if (I + 1 != DotDebugLocEntries.end())
2446       Entry.Merge(I+1);
2447   }
2448
2449   // Start the dwarf loc section.
2450   Asm->OutStreamer.SwitchSection(
2451     Asm->getObjFileLowering().getDwarfLocSection());
2452   unsigned char Size = Asm->getDataLayout().getPointerSize();
2453   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2454   unsigned index = 1;
2455   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2456          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2457        I != E; ++I, ++index) {
2458     DotDebugLocEntry &Entry = *I;
2459     if (Entry.isMerged()) continue;
2460     if (Entry.isEmpty()) {
2461       Asm->OutStreamer.EmitIntValue(0, Size);
2462       Asm->OutStreamer.EmitIntValue(0, Size);
2463       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2464     } else {
2465       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2466       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2467       DIVariable DV(Entry.getVariable());
2468       Asm->OutStreamer.AddComment("Loc expr size");
2469       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2470       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2471       Asm->EmitLabelDifference(end, begin, 2);
2472       Asm->OutStreamer.EmitLabel(begin);
2473       if (Entry.isInt()) {
2474         DIBasicType BTy(DV.getType());
2475         if (BTy.Verify() &&
2476             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2477              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2478           Asm->OutStreamer.AddComment("DW_OP_consts");
2479           Asm->EmitInt8(dwarf::DW_OP_consts);
2480           Asm->EmitSLEB128(Entry.getInt());
2481         } else {
2482           Asm->OutStreamer.AddComment("DW_OP_constu");
2483           Asm->EmitInt8(dwarf::DW_OP_constu);
2484           Asm->EmitULEB128(Entry.getInt());
2485         }
2486       } else if (Entry.isLocation()) {
2487         MachineLocation Loc = Entry.getLoc();
2488         if (!DV.hasComplexAddress())
2489           // Regular entry.
2490           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2491         else {
2492           // Complex address entry.
2493           unsigned N = DV.getNumAddrElements();
2494           unsigned i = 0;
2495           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2496             if (Loc.getOffset()) {
2497               i = 2;
2498               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2499               Asm->OutStreamer.AddComment("DW_OP_deref");
2500               Asm->EmitInt8(dwarf::DW_OP_deref);
2501               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2502               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2503               Asm->EmitSLEB128(DV.getAddrElement(1));
2504             } else {
2505               // If first address element is OpPlus then emit
2506               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2507               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2508               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2509               i = 2;
2510             }
2511           } else {
2512             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2513           }
2514
2515           // Emit remaining complex address elements.
2516           for (; i < N; ++i) {
2517             uint64_t Element = DV.getAddrElement(i);
2518             if (Element == DIBuilder::OpPlus) {
2519               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2520               Asm->EmitULEB128(DV.getAddrElement(++i));
2521             } else if (Element == DIBuilder::OpDeref) {
2522               if (!Loc.isReg())
2523                 Asm->EmitInt8(dwarf::DW_OP_deref);
2524             } else
2525               llvm_unreachable("unknown Opcode found in complex address");
2526           }
2527         }
2528       }
2529       // else ... ignore constant fp. There is not any good way to
2530       // to represent them here in dwarf.
2531       Asm->OutStreamer.EmitLabel(end);
2532     }
2533   }
2534 }
2535
2536 // Emit visible names into a debug aranges section.
2537 void DwarfDebug::emitDebugARanges() {
2538   // Start the dwarf aranges section.
2539   Asm->OutStreamer
2540       .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2541 }
2542
2543 // Emit visible names into a debug ranges section.
2544 void DwarfDebug::emitDebugRanges() {
2545   // Start the dwarf ranges section.
2546   Asm->OutStreamer
2547       .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2548   unsigned char Size = Asm->getDataLayout().getPointerSize();
2549   for (SmallVectorImpl<const MCSymbol *>::iterator
2550          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2551        I != E; ++I) {
2552     if (*I)
2553       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2554     else
2555       Asm->OutStreamer.EmitIntValue(0, Size);
2556   }
2557 }
2558
2559 // Emit visible names into a debug macinfo section.
2560 void DwarfDebug::emitDebugMacInfo() {
2561   if (const MCSection *LineInfo =
2562       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2563     // Start the dwarf macinfo section.
2564     Asm->OutStreamer.SwitchSection(LineInfo);
2565   }
2566 }
2567
2568 // DWARF5 Experimental Separate Dwarf emitters.
2569
2570 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2571 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2572 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2573 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2574 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2575
2576   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2577   CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2578                                        Asm, this, &SkeletonHolder);
2579
2580   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2581                         DICompileUnit(CU->getNode()).getSplitDebugFilename());
2582
2583   // Relocate to the beginning of the addr_base section, else 0 for the
2584   // beginning of the one for this compile unit.
2585   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2586     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2587                     DwarfAddrSectionSym);
2588   else
2589     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2590                    dwarf::DW_FORM_sec_offset, 0);
2591
2592   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2593   // into an entity. We're using 0, or a NULL label for this.
2594   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2595
2596   // DW_AT_stmt_list is a offset of line number information for this
2597   // compile unit in debug_line section.
2598   // FIXME: Should handle multiple compile units.
2599   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2600     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2601                     DwarfLineSectionSym);
2602   else
2603     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2604
2605   if (!CompilationDir.empty())
2606     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2607
2608   SkeletonHolder.addUnit(NewCU);
2609   SkeletonCUs.push_back(NewCU);
2610
2611   return NewCU;
2612 }
2613
2614 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2615   assert(useSplitDwarf() && "No split dwarf debug info?");
2616   emitAbbrevs(Section, &SkeletonAbbrevs);
2617 }
2618
2619 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2620 // compile units that would normally be in debug_info.
2621 void DwarfDebug::emitDebugInfoDWO() {
2622   assert(useSplitDwarf() && "No split dwarf debug info?");
2623   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2624                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2625                        DwarfAbbrevDWOSectionSym);
2626 }
2627
2628 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2629 // abbreviations for the .debug_info.dwo section.
2630 void DwarfDebug::emitDebugAbbrevDWO() {
2631   assert(useSplitDwarf() && "No split dwarf?");
2632   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2633               &Abbreviations);
2634 }
2635
2636 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2637 // string section and is identical in format to traditional .debug_str
2638 // sections.
2639 void DwarfDebug::emitDebugStrDWO() {
2640   assert(useSplitDwarf() && "No split dwarf?");
2641   const MCSection *OffSec = Asm->getObjFileLowering()
2642                             .getDwarfStrOffDWOSection();
2643   const MCSymbol *StrSym = DwarfStrSectionSym;
2644   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2645                          OffSec, StrSym);
2646 }