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