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 DwarfPubNames("generate-dwarf-pubnames", cl::Hidden,
 105               cl::desc("Generate DWARF pubnames section"),
 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 (DwarfPubNames == Default)
 221     HasDwarfPubNames = !IsDarwin;
 222   else
 223     HasDwarfPubNames = DwarfPubNames == 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 (HasDwarfPubNames)
 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 (HasDwarfPubNames)
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())
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 (HasDwarfPubNames)
1931     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1932   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1933   DwarfStrSectionSym =
1934     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1935   if (useSplitDwarf()) {
1936     DwarfStrDWOSectionSym =
1937       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1938     DwarfAddrSectionSym =
1939       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1940   }
1941   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1942                                              "debug_range");
1943
1944   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1945                                            "section_debug_loc");
1946
1947   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1948   emitSectionSym(Asm, TLOF.getDataSection());
1949 }
1950
1951 // Recursively emits a debug information entry.
1952 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1953   // Get the abbreviation for this DIE.
1954   unsigned AbbrevNumber = Die->getAbbrevNumber();
1955   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1956
1957   // Emit the code (index) for the abbreviation.
1958   if (Asm->isVerbose())
1959     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1960                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1961                                 Twine::utohexstr(Die->getSize()) + " " +
1962                                 dwarf::TagString(Abbrev->getTag()));
1963   Asm->EmitULEB128(AbbrevNumber);
1964
1965   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1966   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1967
1968   // Emit the DIE attribute values.
1969   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1970     unsigned Attr = AbbrevData[i].getAttribute();
1971     unsigned Form = AbbrevData[i].getForm();
1972     assert(Form && "Too many attributes for DIE (check abbreviation)");
1973
1974     if (Asm->isVerbose())
1975       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1976
1977     switch (Attr) {
1978     case dwarf::DW_AT_abstract_origin: {
1979       DIEEntry *E = cast<DIEEntry>(Values[i]);
1980       DIE *Origin = E->getEntry();
1981       unsigned Addr = Origin->getOffset();
1982       if (Form == dwarf::DW_FORM_ref_addr) {
1983         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1984         // section. Origin->getOffset() returns the offset from start of the
1985         // compile unit.
1986         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1987         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1988       }
1989       Asm->OutStreamer.EmitIntValue(Addr,
1990           Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
1991       break;
1992     }
1993     case dwarf::DW_AT_ranges: {
1994       // DW_AT_range Value encodes offset in debug_range section.
1995       DIEInteger *V = cast<DIEInteger>(Values[i]);
1996
1997       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1998         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1999                                  V->getValue(),
2000                                  4);
2001       } else {
2002         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2003                                        V->getValue(),
2004                                        DwarfDebugRangeSectionSym,
2005                                        4);
2006       }
2007       break;
2008     }
2009     case dwarf::DW_AT_location: {
2010       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2011         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2012           Asm->EmitLabelReference(L->getValue(), 4);
2013         else
2014           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2015       } else {
2016         Values[i]->EmitValue(Asm, Form);
2017       }
2018       break;
2019     }
2020     case dwarf::DW_AT_accessibility: {
2021       if (Asm->isVerbose()) {
2022         DIEInteger *V = cast<DIEInteger>(Values[i]);
2023         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2024       }
2025       Values[i]->EmitValue(Asm, Form);
2026       break;
2027     }
2028     default:
2029       // Emit an attribute using the defined form.
2030       Values[i]->EmitValue(Asm, Form);
2031       break;
2032     }
2033   }
2034
2035   // Emit the DIE children if any.
2036   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2037     const std::vector<DIE *> &Children = Die->getChildren();
2038
2039     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2040       emitDIE(Children[j], Abbrevs);
2041
2042     if (Asm->isVerbose())
2043       Asm->OutStreamer.AddComment("End Of Children Mark");
2044     Asm->EmitInt8(0);
2045   }
2046 }
2047
2048 // Emit the various dwarf units to the unit section USection with
2049 // the abbreviations going into ASection.
2050 void DwarfUnits::emitUnits(DwarfDebug *DD,
2051                            const MCSection *USection,
2052                            const MCSection *ASection,
2053                            const MCSymbol *ASectionSym) {
2054   Asm->OutStreamer.SwitchSection(USection);
2055   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2056          E = CUs.end(); I != E; ++I) {
2057     CompileUnit *TheCU = *I;
2058     DIE *Die = TheCU->getCUDie();
2059
2060     // Emit the compile units header.
2061     Asm->OutStreamer
2062       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2063                                     TheCU->getUniqueID()));
2064
2065     // Emit size of content not including length itself
2066     unsigned ContentSize = Die->getSize() +
2067       sizeof(int16_t) + // DWARF version number
2068       sizeof(int32_t) + // Offset Into Abbrev. Section
2069       sizeof(int8_t);   // Pointer Size (in bytes)
2070
2071     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2072     Asm->EmitInt32(ContentSize);
2073     Asm->OutStreamer.AddComment("DWARF version number");
2074     Asm->EmitInt16(DD->getDwarfVersion());
2075     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2076     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2077                            ASectionSym);
2078     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2079     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2080
2081     DD->emitDIE(Die, Abbreviations);
2082     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2083                                                   TheCU->getUniqueID()));
2084   }
2085 }
2086
2087 /// For a given compile unit DIE, returns offset from beginning of debug info.
2088 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2089   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
2090          "Input DIE should be compile unit in getCUOffset.");
2091   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2092        I != E; ++I) {
2093     CompileUnit *TheCU = *I;
2094     if (TheCU->getCUDie() == Die)
2095       return TheCU->getDebugInfoOffset();
2096   }
2097   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2098 }
2099
2100 // Emit the debug info section.
2101 void DwarfDebug::emitDebugInfo() {
2102   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2103
2104   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2105                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2106                    DwarfAbbrevSectionSym);
2107 }
2108
2109 // Emit the abbreviation section.
2110 void DwarfDebug::emitAbbreviations() {
2111   if (!useSplitDwarf())
2112     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2113                 &Abbreviations);
2114   else
2115     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2116 }
2117
2118 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2119                              std::vector<DIEAbbrev *> *Abbrevs) {
2120   // Check to see if it is worth the effort.
2121   if (!Abbrevs->empty()) {
2122     // Start the debug abbrev section.
2123     Asm->OutStreamer.SwitchSection(Section);
2124
2125     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2126     Asm->OutStreamer.EmitLabel(Begin);
2127
2128     // For each abbrevation.
2129     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2130       // Get abbreviation data
2131       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2132
2133       // Emit the abbrevations code (base 1 index.)
2134       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2135
2136       // Emit the abbreviations data.
2137       Abbrev->Emit(Asm);
2138     }
2139
2140     // Mark end of abbreviations.
2141     Asm->EmitULEB128(0, "EOM(3)");
2142
2143     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2144     Asm->OutStreamer.EmitLabel(End);
2145   }
2146 }
2147
2148 // Emit the last address of the section and the end of the line matrix.
2149 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2150   // Define last address of section.
2151   Asm->OutStreamer.AddComment("Extended Op");
2152   Asm->EmitInt8(0);
2153
2154   Asm->OutStreamer.AddComment("Op size");
2155   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2156   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2157   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2158
2159   Asm->OutStreamer.AddComment("Section end label");
2160
2161   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2162                                    Asm->getDataLayout().getPointerSize());
2163
2164   // Mark end of matrix.
2165   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2166   Asm->EmitInt8(0);
2167   Asm->EmitInt8(1);
2168   Asm->EmitInt8(1);
2169 }
2170
2171 // Emit visible names into a hashed accelerator table section.
2172 void DwarfDebug::emitAccelNames() {
2173   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2174                                            dwarf::DW_FORM_data4));
2175   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2176          E = CUMap.end(); I != E; ++I) {
2177     CompileUnit *TheCU = I->second;
2178     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2179     for (StringMap<std::vector<DIE*> >::const_iterator
2180            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2181       StringRef Name = GI->getKey();
2182       const std::vector<DIE *> &Entities = GI->second;
2183       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2184              DE = Entities.end(); DI != DE; ++DI)
2185         AT.AddName(Name, (*DI));
2186     }
2187   }
2188
2189   AT.FinalizeTable(Asm, "Names");
2190   Asm->OutStreamer.SwitchSection(
2191     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2192   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2193   Asm->OutStreamer.EmitLabel(SectionBegin);
2194
2195   // Emit the full data.
2196   AT.Emit(Asm, SectionBegin, &InfoHolder);
2197 }
2198
2199 // Emit objective C classes and categories into a hashed accelerator table
2200 // section.
2201 void DwarfDebug::emitAccelObjC() {
2202   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2203                                            dwarf::DW_FORM_data4));
2204   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2205          E = CUMap.end(); I != E; ++I) {
2206     CompileUnit *TheCU = I->second;
2207     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2208     for (StringMap<std::vector<DIE*> >::const_iterator
2209            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2210       StringRef Name = GI->getKey();
2211       const std::vector<DIE *> &Entities = GI->second;
2212       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2213              DE = Entities.end(); DI != DE; ++DI)
2214         AT.AddName(Name, (*DI));
2215     }
2216   }
2217
2218   AT.FinalizeTable(Asm, "ObjC");
2219   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2220                                  .getDwarfAccelObjCSection());
2221   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2222   Asm->OutStreamer.EmitLabel(SectionBegin);
2223
2224   // Emit the full data.
2225   AT.Emit(Asm, SectionBegin, &InfoHolder);
2226 }
2227
2228 // Emit namespace dies into a hashed accelerator table.
2229 void DwarfDebug::emitAccelNamespaces() {
2230   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2231                                            dwarf::DW_FORM_data4));
2232   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2233          E = CUMap.end(); I != E; ++I) {
2234     CompileUnit *TheCU = I->second;
2235     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2236     for (StringMap<std::vector<DIE*> >::const_iterator
2237            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2238       StringRef Name = GI->getKey();
2239       const std::vector<DIE *> &Entities = GI->second;
2240       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2241              DE = Entities.end(); DI != DE; ++DI)
2242         AT.AddName(Name, (*DI));
2243     }
2244   }
2245
2246   AT.FinalizeTable(Asm, "namespac");
2247   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2248                                  .getDwarfAccelNamespaceSection());
2249   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2250   Asm->OutStreamer.EmitLabel(SectionBegin);
2251
2252   // Emit the full data.
2253   AT.Emit(Asm, SectionBegin, &InfoHolder);
2254 }
2255
2256 // Emit type dies into a hashed accelerator table.
2257 void DwarfDebug::emitAccelTypes() {
2258   std::vector<DwarfAccelTable::Atom> Atoms;
2259   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2260                                         dwarf::DW_FORM_data4));
2261   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2262                                         dwarf::DW_FORM_data2));
2263   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2264                                         dwarf::DW_FORM_data1));
2265   DwarfAccelTable AT(Atoms);
2266   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2267          E = CUMap.end(); I != E; ++I) {
2268     CompileUnit *TheCU = I->second;
2269     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2270       = TheCU->getAccelTypes();
2271     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2272            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2273       StringRef Name = GI->getKey();
2274       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2275       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2276              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2277         AT.AddName(Name, (*DI).first, (*DI).second);
2278     }
2279   }
2280
2281   AT.FinalizeTable(Asm, "types");
2282   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2283                                  .getDwarfAccelTypesSection());
2284   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2285   Asm->OutStreamer.EmitLabel(SectionBegin);
2286
2287   // Emit the full data.
2288   AT.Emit(Asm, SectionBegin, &InfoHolder);
2289 }
2290
2291 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2292 ///
2293 void DwarfDebug::emitDebugPubnames() {
2294   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2295
2296   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2297   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2298     CompileUnit *TheCU = I->second;
2299     unsigned ID = TheCU->getUniqueID();
2300
2301     if (TheCU->getGlobalNames().empty())
2302       continue;
2303
2304     // Start the dwarf pubnames section.
2305     Asm->OutStreamer
2306         .SwitchSection(Asm->getObjFileLowering().getDwarfPubNamesSection());
2307
2308     Asm->OutStreamer.AddComment("Length of Public Names Info");
2309     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2310                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2311
2312     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2313
2314     Asm->OutStreamer.AddComment("DWARF Version");
2315     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2316
2317     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2318     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2319                            DwarfInfoSectionSym);
2320
2321     Asm->OutStreamer.AddComment("Compilation Unit Length");
2322     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2323                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2324                              4);
2325
2326     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2327     for (StringMap<DIE*>::const_iterator
2328            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2329       const char *Name = GI->getKeyData();
2330       const DIE *Entity = GI->second;
2331
2332       Asm->OutStreamer.AddComment("DIE offset");
2333       Asm->EmitInt32(Entity->getOffset());
2334
2335       if (Asm->isVerbose())
2336         Asm->OutStreamer.AddComment("External Name");
2337       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2338     }
2339
2340     Asm->OutStreamer.AddComment("End Mark");
2341     Asm->EmitInt32(0);
2342     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2343   }
2344 }
2345
2346 void DwarfDebug::emitDebugPubTypes() {
2347   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2348          E = CUMap.end(); I != E; ++I) {
2349     CompileUnit *TheCU = I->second;
2350     // Start the dwarf pubtypes section.
2351     Asm->OutStreamer.SwitchSection(
2352       Asm->getObjFileLowering().getDwarfPubTypesSection());
2353     Asm->OutStreamer.AddComment("Length of Public Types Info");
2354     Asm->EmitLabelDifference(
2355       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2356       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2357
2358     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2359                                                   TheCU->getUniqueID()));
2360
2361     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2362     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2363
2364     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2365     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2366     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2367                                               TheCU->getUniqueID()),
2368                            DwarfInfoSectionSym);
2369
2370     Asm->OutStreamer.AddComment("Compilation Unit Length");
2371     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2372                                                 TheCU->getUniqueID()),
2373                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2374                                                 TheCU->getUniqueID()),
2375                              4);
2376
2377     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2378     for (StringMap<DIE*>::const_iterator
2379            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2380       const char *Name = GI->getKeyData();
2381       DIE *Entity = GI->second;
2382
2383       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2384       Asm->EmitInt32(Entity->getOffset());
2385
2386       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2387       // Emit the name with a terminating null byte.
2388       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2389     }
2390
2391     Asm->OutStreamer.AddComment("End Mark");
2392     Asm->EmitInt32(0);
2393     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2394                                                   TheCU->getUniqueID()));
2395   }
2396 }
2397
2398 // Emit strings into a string section.
2399 void DwarfUnits::emitStrings(const MCSection *StrSection,
2400                              const MCSection *OffsetSection = NULL,
2401                              const MCSymbol *StrSecSym = NULL) {
2402
2403   if (StringPool.empty()) return;
2404
2405   // Start the dwarf str section.
2406   Asm->OutStreamer.SwitchSection(StrSection);
2407
2408   // Get all of the string pool entries and put them in an array by their ID so
2409   // we can sort them.
2410   SmallVector<std::pair<unsigned,
2411                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2412
2413   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2414          I = StringPool.begin(), E = StringPool.end();
2415        I != E; ++I)
2416     Entries.push_back(std::make_pair(I->second.second, &*I));
2417
2418   array_pod_sort(Entries.begin(), Entries.end());
2419
2420   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2421     // Emit a label for reference from debug information entries.
2422     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2423
2424     // Emit the string itself with a terminating null byte.
2425     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2426                                          Entries[i].second->getKeyLength()+1));
2427   }
2428
2429   // If we've got an offset section go ahead and emit that now as well.
2430   if (OffsetSection) {
2431     Asm->OutStreamer.SwitchSection(OffsetSection);
2432     unsigned offset = 0;
2433     unsigned size = 4; // FIXME: DWARF64 is 8.
2434     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2435       Asm->OutStreamer.EmitIntValue(offset, size);
2436       offset += Entries[i].second->getKeyLength() + 1;
2437     }
2438   }
2439 }
2440
2441 // Emit strings into a string section.
2442 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2443
2444   if (AddressPool.empty()) return;
2445
2446   // Start the dwarf addr section.
2447   Asm->OutStreamer.SwitchSection(AddrSection);
2448
2449   // Order the address pool entries by ID
2450   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2451
2452   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2453                                                     E = AddressPool.end();
2454        I != E; ++I)
2455     Entries[I->second] = I->first;
2456
2457   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2458     // Emit an expression for reference from debug information entries.
2459     if (const MCExpr *Expr = Entries[i])
2460       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2461     else
2462       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2463   }
2464
2465 }
2466
2467 // Emit visible names into a debug str section.
2468 void DwarfDebug::emitDebugStr() {
2469   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2470   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2471 }
2472
2473 // Emit locations into the debug loc section.
2474 void DwarfDebug::emitDebugLoc() {
2475   if (DotDebugLocEntries.empty())
2476     return;
2477
2478   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2479          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2480        I != E; ++I) {
2481     DotDebugLocEntry &Entry = *I;
2482     if (I + 1 != DotDebugLocEntries.end())
2483       Entry.Merge(I+1);
2484   }
2485
2486   // Start the dwarf loc section.
2487   Asm->OutStreamer.SwitchSection(
2488     Asm->getObjFileLowering().getDwarfLocSection());
2489   unsigned char Size = Asm->getDataLayout().getPointerSize();
2490   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2491   unsigned index = 1;
2492   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2493          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2494        I != E; ++I, ++index) {
2495     DotDebugLocEntry &Entry = *I;
2496     if (Entry.isMerged()) continue;
2497     if (Entry.isEmpty()) {
2498       Asm->OutStreamer.EmitIntValue(0, Size);
2499       Asm->OutStreamer.EmitIntValue(0, Size);
2500       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2501     } else {
2502       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2503       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2504       DIVariable DV(Entry.getVariable());
2505       Asm->OutStreamer.AddComment("Loc expr size");
2506       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2507       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2508       Asm->EmitLabelDifference(end, begin, 2);
2509       Asm->OutStreamer.EmitLabel(begin);
2510       if (Entry.isInt()) {
2511         DIBasicType BTy(DV.getType());
2512         if (BTy.Verify() &&
2513             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2514              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2515           Asm->OutStreamer.AddComment("DW_OP_consts");
2516           Asm->EmitInt8(dwarf::DW_OP_consts);
2517           Asm->EmitSLEB128(Entry.getInt());
2518         } else {
2519           Asm->OutStreamer.AddComment("DW_OP_constu");
2520           Asm->EmitInt8(dwarf::DW_OP_constu);
2521           Asm->EmitULEB128(Entry.getInt());
2522         }
2523       } else if (Entry.isLocation()) {
2524         MachineLocation Loc = Entry.getLoc();
2525         if (!DV.hasComplexAddress())
2526           // Regular entry.
2527           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2528         else {
2529           // Complex address entry.
2530           unsigned N = DV.getNumAddrElements();
2531           unsigned i = 0;
2532           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2533             if (Loc.getOffset()) {
2534               i = 2;
2535               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2536               Asm->OutStreamer.AddComment("DW_OP_deref");
2537               Asm->EmitInt8(dwarf::DW_OP_deref);
2538               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2539               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2540               Asm->EmitSLEB128(DV.getAddrElement(1));
2541             } else {
2542               // If first address element is OpPlus then emit
2543               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2544               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2545               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2546               i = 2;
2547             }
2548           } else {
2549             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2550           }
2551
2552           // Emit remaining complex address elements.
2553           for (; i < N; ++i) {
2554             uint64_t Element = DV.getAddrElement(i);
2555             if (Element == DIBuilder::OpPlus) {
2556               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2557               Asm->EmitULEB128(DV.getAddrElement(++i));
2558             } else if (Element == DIBuilder::OpDeref) {
2559               if (!Loc.isReg())
2560                 Asm->EmitInt8(dwarf::DW_OP_deref);
2561             } else
2562               llvm_unreachable("unknown Opcode found in complex address");
2563           }
2564         }
2565       }
2566       // else ... ignore constant fp. There is not any good way to
2567       // to represent them here in dwarf.
2568       Asm->OutStreamer.EmitLabel(end);
2569     }
2570   }
2571 }
2572
2573 // Emit visible names into a debug aranges section.
2574 void DwarfDebug::emitDebugARanges() {
2575   // Start the dwarf aranges section.
2576   Asm->OutStreamer.SwitchSection(
2577                           Asm->getObjFileLowering().getDwarfARangesSection());
2578 }
2579
2580 // Emit visible names into a debug ranges section.
2581 void DwarfDebug::emitDebugRanges() {
2582   // Start the dwarf ranges section.
2583   Asm->OutStreamer.SwitchSection(
2584     Asm->getObjFileLowering().getDwarfRangesSection());
2585   unsigned char Size = Asm->getDataLayout().getPointerSize();
2586   for (SmallVectorImpl<const MCSymbol *>::iterator
2587          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2588        I != E; ++I) {
2589     if (*I)
2590       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2591     else
2592       Asm->OutStreamer.EmitIntValue(0, Size);
2593   }
2594 }
2595
2596 // Emit visible names into a debug macinfo section.
2597 void DwarfDebug::emitDebugMacInfo() {
2598   if (const MCSection *LineInfo =
2599       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2600     // Start the dwarf macinfo section.
2601     Asm->OutStreamer.SwitchSection(LineInfo);
2602   }
2603 }
2604
2605 // Emit inline info using following format.
2606 // Section Header:
2607 // 1. length of section
2608 // 2. Dwarf version number
2609 // 3. address size.
2610 //
2611 // Entries (one "entry" for each function that was inlined):
2612 //
2613 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2614 //   otherwise offset into __debug_str for regular function name.
2615 // 2. offset into __debug_str section for regular function name.
2616 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2617 // instances for the function.
2618 //
2619 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2620 // inlined instance; the die_offset points to the inlined_subroutine die in the
2621 // __debug_info section, and the low_pc is the starting address for the
2622 // inlining instance.
2623 void DwarfDebug::emitDebugInlineInfo() {
2624   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2625     return;
2626
2627   if (!FirstCU)
2628     return;
2629
2630   Asm->OutStreamer.SwitchSection(
2631                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2632
2633   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2634   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2635                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2636
2637   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2638
2639   Asm->OutStreamer.AddComment("Dwarf Version");
2640   Asm->EmitInt16(DwarfVersion);
2641   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2642   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2643
2644   for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2645          E = InlinedSPNodes.end(); I != E; ++I) {
2646
2647     const MDNode *Node = *I;
2648     InlineInfoMap::iterator II = InlineInfo.find(Node);
2649     SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2650     DISubprogram SP(Node);
2651     StringRef LName = SP.getLinkageName();
2652     StringRef Name = SP.getName();
2653
2654     Asm->OutStreamer.AddComment("MIPS linkage name");
2655     if (LName.empty())
2656       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2657                              DwarfStrSectionSym);
2658     else
2659       Asm->EmitSectionOffset(
2660           InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2661           DwarfStrSectionSym);
2662
2663     Asm->OutStreamer.AddComment("Function name");
2664     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2665                            DwarfStrSectionSym);
2666     Asm->EmitULEB128(Labels.size(), "Inline count");
2667
2668     for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2669            LE = Labels.end(); LI != LE; ++LI) {
2670       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2671       Asm->EmitInt32(LI->second->getOffset());
2672
2673       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2674       Asm->OutStreamer.EmitSymbolValue(LI->first,
2675                                        Asm->getDataLayout().getPointerSize());
2676     }
2677   }
2678
2679   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2680 }
2681
2682 // DWARF5 Experimental Separate Dwarf emitters.
2683
2684 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2685 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2686 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2687 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2688 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2689   DICompileUnit DIUnit(N);
2690   CompilationDir = DIUnit.getDirectory();
2691
2692   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2693   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2694                                        DIUnit.getLanguage(), Die, N, Asm,
2695                                        this, &SkeletonHolder);
2696
2697   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2698                         DIUnit.getSplitDebugFilename());
2699
2700   // Relocate to the beginning of the addr_base section, else 0 for the
2701   // beginning of the one for this compile unit.
2702   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2703     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2704                     DwarfAddrSectionSym);
2705   else
2706     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2707                    dwarf::DW_FORM_sec_offset, 0);
2708
2709   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2710   // into an entity. We're using 0, or a NULL label for this.
2711   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2712
2713   // DW_AT_stmt_list is a offset of line number information for this
2714   // compile unit in debug_line section.
2715   // FIXME: Should handle multiple compile units.
2716   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2717     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2718                     DwarfLineSectionSym);
2719   else
2720     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2721
2722   if (!CompilationDir.empty())
2723     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2724
2725   SkeletonHolder.addUnit(NewCU);
2726   SkeletonCUs.push_back(NewCU);
2727
2728   return NewCU;
2729 }
2730
2731 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2732   assert(useSplitDwarf() && "No split dwarf debug info?");
2733   emitAbbrevs(Section, &SkeletonAbbrevs);
2734 }
2735
2736 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2737 // compile units that would normally be in debug_info.
2738 void DwarfDebug::emitDebugInfoDWO() {
2739   assert(useSplitDwarf() && "No split dwarf debug info?");
2740   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2741                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2742                        DwarfAbbrevDWOSectionSym);
2743 }
2744
2745 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2746 // abbreviations for the .debug_info.dwo section.
2747 void DwarfDebug::emitDebugAbbrevDWO() {
2748   assert(useSplitDwarf() && "No split dwarf?");
2749   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2750               &Abbreviations);
2751 }
2752
2753 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2754 // string section and is identical in format to traditional .debug_str
2755 // sections.
2756 void DwarfDebug::emitDebugStrDWO() {
2757   assert(useSplitDwarf() && "No split dwarf?");
2758   const MCSection *OffSec = Asm->getObjFileLowering()
2759                             .getDwarfStrOffDWOSection();
2760   const MCSymbol *StrSym = DwarfStrSectionSym;
2761   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2762                          OffSec, StrSym);
2763 }