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