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