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