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