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