lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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