lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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