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