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