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 = DD->resolve(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 (DD->resolve(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_pubtypes",
 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   // Expose as a global name.
 842   TheCU->addGlobalName(SP.getName(), SubprogramDie);
 843 }
 844
 845 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 846                                             const MDNode *N) {
 847   DIImportedEntity Module(N);
 848   if (!Module.Verify())
 849     return;
 850   if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
 851     constructImportedEntityDIE(TheCU, Module, D);
 852 }
 853
 854 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
 855                                             DIE *Context) {
 856   DIImportedEntity Module(N);
 857   if (!Module.Verify())
 858     return;
 859   return constructImportedEntityDIE(TheCU, Module, Context);
 860 }
 861
 862 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 863                                             const DIImportedEntity &Module,
 864                                             DIE *Context) {
 865   assert(Module.Verify() &&
 866          "Use one of the MDNode * overloads to handle invalid metadata");
 867   assert(Context && "Should always have a context for an imported_module");
 868   DIE *IMDie = new DIE(Module.getTag());
 869   TheCU->insertDIE(Module, IMDie);
 870   DIE *EntityDie;
 871   DIDescriptor Entity = Module.getEntity();
 872   if (Entity.isNameSpace())
 873     EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
 874   else if (Entity.isSubprogram())
 875     EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
 876   else if (Entity.isType())
 877     EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
 878   else
 879     EntityDie = TheCU->getDIE(Entity);
 880   unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
 881                                         Module.getContext().getDirectory(),
 882                                         TheCU->getUniqueID());
 883   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
 884   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
 885   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
 886                      EntityDie);
 887   StringRef Name = Module.getName();
 888   if (!Name.empty())
 889     TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
 890   Context->addChild(IMDie);
 891 }
 892
 893 // Emit all Dwarf sections that should come prior to the content. Create
 894 // global DIEs and emit initial debug info sections. This is invoked by
 895 // the target AsmPrinter.
 896 void DwarfDebug::beginModule() {
 897   if (DisableDebugInfoPrinting)
 898     return;
 899
 900   const Module *M = MMI->getModule();
 901
 902   // If module has named metadata anchors then use them, otherwise scan the
 903   // module using debug info finder to collect debug info.
 904   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 905   if (!CU_Nodes)
 906     return;
 907   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
 908
 909   // Emit initial sections so we can reference labels later.
 910   emitSectionLabels();
 911
 912   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 913     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 914     CompileUnit *CU = constructCompileUnit(CUNode);
 915     DIArray ImportedEntities = CUNode.getImportedEntities();
 916     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 917       ScopesWithImportedEntities.push_back(std::make_pair(
 918           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
 919           ImportedEntities.getElement(i)));
 920     std::sort(ScopesWithImportedEntities.begin(),
 921               ScopesWithImportedEntities.end(), less_first());
 922     DIArray GVs = CUNode.getGlobalVariables();
 923     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 924       CU->createGlobalVariableDIE(GVs.getElement(i));
 925     DIArray SPs = CUNode.getSubprograms();
 926     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 927       constructSubprogramDIE(CU, SPs.getElement(i));
 928     DIArray EnumTypes = CUNode.getEnumTypes();
 929     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 930       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 931     DIArray RetainedTypes = CUNode.getRetainedTypes();
 932     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 933       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 934     // Emit imported_modules last so that the relevant context is already
 935     // available.
 936     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 937       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
 938   }
 939
 940   // Tell MMI that we have debug info.
 941   MMI->setDebugInfoAvailability(true);
 942
 943   // Prime section data.
 944   SectionMap[Asm->getObjFileLowering().getTextSection()];
 945 }
 946
 947 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 948 void DwarfDebug::computeInlinedDIEs() {
 949   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 950   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 951          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 952     DIE *ISP = *AI;
 953     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 954   }
 955   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 956          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 957     DIE *ISP = AI->second;
 958     if (InlinedSubprogramDIEs.count(ISP))
 959       continue;
 960     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 961   }
 962 }
 963
 964 // Collect info for variables that were optimized out.
 965 void DwarfDebug::collectDeadVariables() {
 966   const Module *M = MMI->getModule();
 967   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 968
 969   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 970     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 971       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 972       DIArray Subprograms = TheCU.getSubprograms();
 973       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 974         DISubprogram SP(Subprograms.getElement(i));
 975         if (ProcessedSPNodes.count(SP) != 0) continue;
 976         if (!SP.isSubprogram()) continue;
 977         if (!SP.isDefinition()) continue;
 978         DIArray Variables = SP.getVariables();
 979         if (Variables.getNumElements() == 0) continue;
 980
 981         LexicalScope *Scope =
 982           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 983         DeadFnScopeMap[SP] = Scope;
 984
 985         // Construct subprogram DIE and add variables DIEs.
 986         CompileUnit *SPCU = CUMap.lookup(TheCU);
 987         assert(SPCU && "Unable to find Compile Unit!");
 988         constructSubprogramDIE(SPCU, SP);
 989         DIE *ScopeDIE = getSPDIE(SP);
 990         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 991           DIVariable DV(Variables.getElement(vi));
 992           if (!DV.isVariable()) continue;
 993           DbgVariable NewVar(DV, NULL, this);
 994           if (DIE *VariableDIE =
 995               SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
 996             ScopeDIE->addChild(VariableDIE);
 997         }
 998       }
 999     }
1000   }
1001   DeleteContainerSeconds(DeadFnScopeMap);
1002 }
1003
1004 // Type Signature [7.27] and ODR Hash code.
1005
1006 /// \brief Grabs the string in whichever attribute is passed in and returns
1007 /// a reference to it. Returns "" if the attribute doesn't exist.
1008 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1009   DIEValue *V = Die->findAttribute(Attr);
1010
1011   if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1012     return S->getString();
1013
1014   return StringRef("");
1015 }
1016
1017 /// Return true if the current DIE is contained within an anonymous namespace.
1018 static bool isContainedInAnonNamespace(DIE *Die) {
1019   DIE *Parent = Die->getParent();
1020
1021   while (Parent) {
1022     if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1023         getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1024       return true;
1025     Parent = Parent->getParent();
1026   }
1027
1028   return false;
1029 }
1030
1031 /// Test if the current CU language is C++ and that we have
1032 /// a named type that is not contained in an anonymous namespace.
1033 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1034   return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1035          getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1036          !isContainedInAnonNamespace(Die);
1037 }
1038
1039 void DwarfDebug::finalizeModuleInfo() {
1040   // Collect info for variables that were optimized out.
1041   collectDeadVariables();
1042
1043   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1044   computeInlinedDIEs();
1045
1046   // Split out type units and conditionally add an ODR tag to the split
1047   // out type.
1048   // FIXME: Do type splitting.
1049   for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1050     DIE *Die = TypeUnits[i];
1051     DIEHash Hash;
1052     // If we've requested ODR hashes and it's applicable for an ODR hash then
1053     // add the ODR signature now.
1054     // FIXME: This should be added onto the type unit, not the type, but this
1055     // works as an intermediate stage.
1056     if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1057       CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1058                                      dwarf::DW_FORM_data8,
1059                                      Hash.computeDIEODRSignature(Die));
1060   }
1061
1062   // Process the worklist to add attributes with the correct form (ref_addr or
1063   // ref4).
1064   for (unsigned I = 0, E = DIEEntryWorklist.size(); I < E; I++) {
1065     addDIEEntry(DIEEntryWorklist[I].Die, DIEEntryWorklist[I].Attribute,
1066                 dwarf::DW_FORM_ref4, DIEEntryWorklist[I].Entry);
1067     assert(E == DIEEntryWorklist.size() &&
1068            "We should not add to the worklist during finalization.");
1069   }
1070
1071   // Handle anything that needs to be done on a per-cu basis.
1072   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1073                                                          CUE = CUMap.end();
1074        CUI != CUE; ++CUI) {
1075     CompileUnit *TheCU = CUI->second;
1076     // Emit DW_AT_containing_type attribute to connect types with their
1077     // vtable holding type.
1078     TheCU->constructContainingTypeDIEs();
1079
1080     // If we're splitting the dwarf out now that we've got the entire
1081     // CU then construct a skeleton CU based upon it.
1082     if (useSplitDwarf()) {
1083       uint64_t ID = 0;
1084       if (GenerateCUHash) {
1085         DIEHash CUHash;
1086         ID = CUHash.computeCUSignature(TheCU->getCUDie());
1087       }
1088       // This should be a unique identifier when we want to build .dwp files.
1089       TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1090                      dwarf::DW_FORM_data8, ID);
1091       // Now construct the skeleton CU associated.
1092       CompileUnit *SkCU = constructSkeletonCU(TheCU);
1093       // This should be a unique identifier when we want to build .dwp files.
1094       SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1095                     dwarf::DW_FORM_data8, ID);
1096     }
1097   }
1098
1099   // Compute DIE offsets and sizes.
1100   InfoHolder.computeSizeAndOffsets();
1101   if (useSplitDwarf())
1102     SkeletonHolder.computeSizeAndOffsets();
1103 }
1104
1105 void DwarfDebug::endSections() {
1106    // Filter labels by section.
1107   for (size_t n = 0; n < ArangeLabels.size(); n++) {
1108     const SymbolCU &SCU = ArangeLabels[n];
1109     if (SCU.Sym->isInSection()) {
1110       // Make a note of this symbol and it's section.
1111       const MCSection *Section = &SCU.Sym->getSection();
1112       if (!Section->getKind().isMetadata())
1113         SectionMap[Section].push_back(SCU);
1114     } else {
1115       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1116       // appear in the output. This sucks as we rely on sections to build
1117       // arange spans. We can do it without, but it's icky.
1118       SectionMap[NULL].push_back(SCU);
1119     }
1120   }
1121
1122   // Add terminating symbols for each section.
1123   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1124        it++) {
1125     const MCSection *Section = it->first;
1126     MCSymbol *Sym = NULL;
1127
1128     if (Section) {
1129       Sym = Asm->GetTempSymbol(Section->getLabelEndName());
1130       Asm->OutStreamer.SwitchSection(Section);
1131       Asm->OutStreamer.EmitLabel(Sym);
1132     }
1133
1134     // Insert a final terminator.
1135     SectionMap[Section].push_back(SymbolCU(NULL, Sym));
1136   }
1137 }
1138
1139 // Emit all Dwarf sections that should come after the content.
1140 void DwarfDebug::endModule() {
1141
1142   if (!FirstCU) return;
1143
1144   // End any existing sections.
1145   // TODO: Does this need to happen?
1146   endSections();
1147
1148   // Finalize the debug info for the module.
1149   finalizeModuleInfo();
1150
1151   if (!useSplitDwarf()) {
1152     emitDebugStr();
1153
1154     // Emit all the DIEs into a debug info section.
1155     emitDebugInfo();
1156
1157     // Corresponding abbreviations into a abbrev section.
1158     emitAbbreviations();
1159
1160     // Emit info into a debug loc section.
1161     emitDebugLoc();
1162
1163     // Emit info into a debug aranges section.
1164     emitDebugARanges();
1165
1166     // Emit info into a debug ranges section.
1167     emitDebugRanges();
1168
1169     // Emit info into a debug macinfo section.
1170     emitDebugMacInfo();
1171
1172   } else {
1173     // TODO: Fill this in for separated debug sections and separate
1174     // out information into new sections.
1175     emitDebugStr();
1176     if (useSplitDwarf())
1177       emitDebugStrDWO();
1178
1179     // Emit the debug info section and compile units.
1180     emitDebugInfo();
1181     emitDebugInfoDWO();
1182
1183     // Corresponding abbreviations into a abbrev section.
1184     emitAbbreviations();
1185     emitDebugAbbrevDWO();
1186
1187     // Emit info into a debug loc section.
1188     emitDebugLoc();
1189
1190     // Emit info into a debug aranges section.
1191     emitDebugARanges();
1192
1193     // Emit info into a debug ranges section.
1194     emitDebugRanges();
1195
1196     // Emit info into a debug macinfo section.
1197     emitDebugMacInfo();
1198
1199     // Emit DWO addresses.
1200     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1201
1202   }
1203
1204   // Emit info into the dwarf accelerator table sections.
1205   if (useDwarfAccelTables()) {
1206     emitAccelNames();
1207     emitAccelObjC();
1208     emitAccelNamespaces();
1209     emitAccelTypes();
1210   }
1211
1212   // Emit the pubnames and pubtypes sections if requested.
1213   if (HasDwarfPubSections) {
1214     emitDebugPubNames(GenerateGnuPubSections);
1215     emitDebugPubTypes(GenerateGnuPubSections);
1216   }
1217
1218   // clean up.
1219   SPMap.clear();
1220   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1221          E = CUMap.end(); I != E; ++I)
1222     delete I->second;
1223
1224   for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1225          E = SkeletonCUs.end(); I != E; ++I)
1226     delete *I;
1227
1228   // Reset these for the next Module if we have one.
1229   FirstCU = NULL;
1230 }
1231
1232 // Find abstract variable, if any, associated with Var.
1233 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1234                                               DebugLoc ScopeLoc) {
1235   LLVMContext &Ctx = DV->getContext();
1236   // More then one inlined variable corresponds to one abstract variable.
1237   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1238   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1239   if (AbsDbgVariable)
1240     return AbsDbgVariable;
1241
1242   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1243   if (!Scope)
1244     return NULL;
1245
1246   AbsDbgVariable = new DbgVariable(Var, NULL, this);
1247   addScopeVariable(Scope, AbsDbgVariable);
1248   AbstractVariables[Var] = AbsDbgVariable;
1249   return AbsDbgVariable;
1250 }
1251
1252 // If Var is a current function argument then add it to CurrentFnArguments list.
1253 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1254                                       DbgVariable *Var, LexicalScope *Scope) {
1255   if (!LScopes.isCurrentFunctionScope(Scope))
1256     return false;
1257   DIVariable DV = Var->getVariable();
1258   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1259     return false;
1260   unsigned ArgNo = DV.getArgNumber();
1261   if (ArgNo == 0)
1262     return false;
1263
1264   size_t Size = CurrentFnArguments.size();
1265   if (Size == 0)
1266     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1267   // llvm::Function argument size is not good indicator of how many
1268   // arguments does the function have at source level.
1269   if (ArgNo > Size)
1270     CurrentFnArguments.resize(ArgNo * 2);
1271   CurrentFnArguments[ArgNo - 1] = Var;
1272   return true;
1273 }
1274
1275 // Collect variable information from side table maintained by MMI.
1276 void
1277 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1278                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1279   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1280   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1281          VE = VMap.end(); VI != VE; ++VI) {
1282     const MDNode *Var = VI->first;
1283     if (!Var) continue;
1284     Processed.insert(Var);
1285     DIVariable DV(Var);
1286     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1287
1288     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1289
1290     // If variable scope is not found then skip this variable.
1291     if (Scope == 0)
1292       continue;
1293
1294     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1295     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
1296     RegVar->setFrameIndex(VP.first);
1297     if (!addCurrentFnArgument(MF, RegVar, Scope))
1298       addScopeVariable(Scope, RegVar);
1299     if (AbsDbgVariable)
1300       AbsDbgVariable->setFrameIndex(VP.first);
1301   }
1302 }
1303
1304 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1305 // defined reg.
1306 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1307   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1308   return MI->getNumOperands() == 3 &&
1309          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1310          (MI->getOperand(1).isImm() ||
1311           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1312 }
1313
1314 // Get .debug_loc entry for the instruction range starting at MI.
1315 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1316                                          const MCSymbol *FLabel,
1317                                          const MCSymbol *SLabel,
1318                                          const MachineInstr *MI) {
1319   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1320
1321   assert(MI->getNumOperands() == 3);
1322   if (MI->getOperand(0).isReg()) {
1323     MachineLocation MLoc;
1324     // If the second operand is an immediate, this is a
1325     // register-indirect address.
1326     if (!MI->getOperand(1).isImm())
1327       MLoc.set(MI->getOperand(0).getReg());
1328     else
1329       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1330     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1331   }
1332   if (MI->getOperand(0).isImm())
1333     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1334   if (MI->getOperand(0).isFPImm())
1335     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1336   if (MI->getOperand(0).isCImm())
1337     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1338
1339   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1340 }
1341
1342 // Find variables for each lexical scope.
1343 void
1344 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1345                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1346
1347   // Grab the variable info that was squirreled away in the MMI side-table.
1348   collectVariableInfoFromMMITable(MF, Processed);
1349
1350   for (SmallVectorImpl<const MDNode*>::const_iterator
1351          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1352          ++UVI) {
1353     const MDNode *Var = *UVI;
1354     if (Processed.count(Var))
1355       continue;
1356
1357     // History contains relevant DBG_VALUE instructions for Var and instructions
1358     // clobbering it.
1359     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1360     if (History.empty())
1361       continue;
1362     const MachineInstr *MInsn = History.front();
1363
1364     DIVariable DV(Var);
1365     LexicalScope *Scope = NULL;
1366     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1367         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1368       Scope = LScopes.getCurrentFunctionScope();
1369     else if (MDNode *IA = DV.getInlinedAt())
1370       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1371     else
1372       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1373     // If variable scope is not found then skip this variable.
1374     if (!Scope)
1375       continue;
1376
1377     Processed.insert(DV);
1378     assert(MInsn->isDebugValue() && "History must begin with debug value");
1379     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1380     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
1381     if (!addCurrentFnArgument(MF, RegVar, Scope))
1382       addScopeVariable(Scope, RegVar);
1383     if (AbsVar)
1384       AbsVar->setMInsn(MInsn);
1385
1386     // Simplify ranges that are fully coalesced.
1387     if (History.size() <= 1 || (History.size() == 2 &&
1388                                 MInsn->isIdenticalTo(History.back()))) {
1389       RegVar->setMInsn(MInsn);
1390       continue;
1391     }
1392
1393     // Handle multiple DBG_VALUE instructions describing one variable.
1394     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1395
1396     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1397            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1398       const MachineInstr *Begin = *HI;
1399       assert(Begin->isDebugValue() && "Invalid History entry");
1400
1401       // Check if DBG_VALUE is truncating a range.
1402       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1403           && !Begin->getOperand(0).getReg())
1404         continue;
1405
1406       // Compute the range for a register location.
1407       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1408       const MCSymbol *SLabel = 0;
1409
1410       if (HI + 1 == HE)
1411         // If Begin is the last instruction in History then its value is valid
1412         // until the end of the function.
1413         SLabel = FunctionEndSym;
1414       else {
1415         const MachineInstr *End = HI[1];
1416         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1417               << "\t" << *Begin << "\t" << *End << "\n");
1418         if (End->isDebugValue())
1419           SLabel = getLabelBeforeInsn(End);
1420         else {
1421           // End is a normal instruction clobbering the range.
1422           SLabel = getLabelAfterInsn(End);
1423           assert(SLabel && "Forgot label after clobber instruction");
1424           ++HI;
1425         }
1426       }
1427
1428       // The value is valid until the next DBG_VALUE or clobber.
1429       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1430                                                     Begin));
1431     }
1432     DotDebugLocEntries.push_back(DotDebugLocEntry());
1433   }
1434
1435   // Collect info for variables that were optimized out.
1436   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1437   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1438   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1439     DIVariable DV(Variables.getElement(i));
1440     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1441       continue;
1442     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1443       addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1444   }
1445 }
1446
1447 // Return Label preceding the instruction.
1448 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1449   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1450   assert(Label && "Didn't insert label before instruction");
1451   return Label;
1452 }
1453
1454 // Return Label immediately following the instruction.
1455 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1456   return LabelsAfterInsn.lookup(MI);
1457 }
1458
1459 // Process beginning of an instruction.
1460 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1461   // Check if source location changes, but ignore DBG_VALUE locations.
1462   if (!MI->isDebugValue()) {
1463     DebugLoc DL = MI->getDebugLoc();
1464     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1465       unsigned Flags = 0;
1466       PrevInstLoc = DL;
1467       if (DL == PrologEndLoc) {
1468         Flags |= DWARF2_FLAG_PROLOGUE_END;
1469         PrologEndLoc = DebugLoc();
1470       }
1471       if (PrologEndLoc.isUnknown())
1472         Flags |= DWARF2_FLAG_IS_STMT;
1473
1474       if (!DL.isUnknown()) {
1475         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1476         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1477       } else
1478         recordSourceLine(0, 0, 0, 0);
1479     }
1480   }
1481
1482   // Insert labels where requested.
1483   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1484     LabelsBeforeInsn.find(MI);
1485
1486   // No label needed.
1487   if (I == LabelsBeforeInsn.end())
1488     return;
1489
1490   // Label already assigned.
1491   if (I->second)
1492     return;
1493
1494   if (!PrevLabel) {
1495     PrevLabel = MMI->getContext().CreateTempSymbol();
1496     Asm->OutStreamer.EmitLabel(PrevLabel);
1497   }
1498   I->second = PrevLabel;
1499 }
1500
1501 // Process end of an instruction.
1502 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1503   // Don't create a new label after DBG_VALUE instructions.
1504   // They don't generate code.
1505   if (!MI->isDebugValue())
1506     PrevLabel = 0;
1507
1508   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1509     LabelsAfterInsn.find(MI);
1510
1511   // No label needed.
1512   if (I == LabelsAfterInsn.end())
1513     return;
1514
1515   // Label already assigned.
1516   if (I->second)
1517     return;
1518
1519   // We need a label after this instruction.
1520   if (!PrevLabel) {
1521     PrevLabel = MMI->getContext().CreateTempSymbol();
1522     Asm->OutStreamer.EmitLabel(PrevLabel);
1523   }
1524   I->second = PrevLabel;
1525 }
1526
1527 // Each LexicalScope has first instruction and last instruction to mark
1528 // beginning and end of a scope respectively. Create an inverse map that list
1529 // scopes starts (and ends) with an instruction. One instruction may start (or
1530 // end) multiple scopes. Ignore scopes that are not reachable.
1531 void DwarfDebug::identifyScopeMarkers() {
1532   SmallVector<LexicalScope *, 4> WorkList;
1533   WorkList.push_back(LScopes.getCurrentFunctionScope());
1534   while (!WorkList.empty()) {
1535     LexicalScope *S = WorkList.pop_back_val();
1536
1537     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1538     if (!Children.empty())
1539       for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1540              SE = Children.end(); SI != SE; ++SI)
1541         WorkList.push_back(*SI);
1542
1543     if (S->isAbstractScope())
1544       continue;
1545
1546     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1547     if (Ranges.empty())
1548       continue;
1549     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1550            RE = Ranges.end(); RI != RE; ++RI) {
1551       assert(RI->first && "InsnRange does not have first instruction!");
1552       assert(RI->second && "InsnRange does not have second instruction!");
1553       requestLabelBeforeInsn(RI->first);
1554       requestLabelAfterInsn(RI->second);
1555     }
1556   }
1557 }
1558
1559 // Get MDNode for DebugLoc's scope.
1560 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1561   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1562     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1563   return DL.getScope(Ctx);
1564 }
1565
1566 // Walk up the scope chain of given debug loc and find line number info
1567 // for the function.
1568 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1569   const MDNode *Scope = getScopeNode(DL, Ctx);
1570   DISubprogram SP = getDISubprogram(Scope);
1571   if (SP.isSubprogram()) {
1572     // Check for number of operands since the compatibility is
1573     // cheap here.
1574     if (SP->getNumOperands() > 19)
1575       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1576     else
1577       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1578   }
1579
1580   return DebugLoc();
1581 }
1582
1583 // Gather pre-function debug information.  Assumes being called immediately
1584 // after the function entry point has been emitted.
1585 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1586   if (!MMI->hasDebugInfo()) return;
1587   LScopes.initialize(*MF);
1588   if (LScopes.empty()) return;
1589   identifyScopeMarkers();
1590
1591   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1592   // belongs to.
1593   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1594   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1595   assert(TheCU && "Unable to find compile unit!");
1596   if (Asm->TM.hasMCUseLoc() &&
1597       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1598     // Use a single line table if we are using .loc and generating assembly.
1599     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1600   else
1601     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1602
1603   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1604                                         Asm->getFunctionNumber());
1605   // Assumes in correct section after the entry point.
1606   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1607
1608   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1609
1610   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1611   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1612   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1613
1614   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1615        I != E; ++I) {
1616     bool AtBlockEntry = true;
1617     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1618          II != IE; ++II) {
1619       const MachineInstr *MI = II;
1620
1621       if (MI->isDebugValue()) {
1622         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1623
1624         // Keep track of user variables.
1625         const MDNode *Var =
1626           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1627
1628         // Variable is in a register, we need to check for clobbers.
1629         if (isDbgValueInDefinedReg(MI))
1630           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1631
1632         // Check the history of this variable.
1633         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1634         if (History.empty()) {
1635           UserVariables.push_back(Var);
1636           // The first mention of a function argument gets the FunctionBeginSym
1637           // label, so arguments are visible when breaking at function entry.
1638           DIVariable DV(Var);
1639           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1640               DISubprogram(getDISubprogram(DV.getContext()))
1641                 .describes(MF->getFunction()))
1642             LabelsBeforeInsn[MI] = FunctionBeginSym;
1643         } else {
1644           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1645           const MachineInstr *Prev = History.back();
1646           if (Prev->isDebugValue()) {
1647             // Coalesce identical entries at the end of History.
1648             if (History.size() >= 2 &&
1649                 Prev->isIdenticalTo(History[History.size() - 2])) {
1650               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1651                     << "\t" << *Prev
1652                     << "\t" << *History[History.size() - 2] << "\n");
1653               History.pop_back();
1654             }
1655
1656             // Terminate old register assignments that don't reach MI;
1657             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1658             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1659                 isDbgValueInDefinedReg(Prev)) {
1660               // Previous register assignment needs to terminate at the end of
1661               // its basic block.
1662               MachineBasicBlock::const_iterator LastMI =
1663                 PrevMBB->getLastNonDebugInstr();
1664               if (LastMI == PrevMBB->end()) {
1665                 // Drop DBG_VALUE for empty range.
1666                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1667                       << "\t" << *Prev << "\n");
1668                 History.pop_back();
1669               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1670                 // Terminate after LastMI.
1671                 History.push_back(LastMI);
1672             }
1673           }
1674         }
1675         History.push_back(MI);
1676       } else {
1677         // Not a DBG_VALUE instruction.
1678         if (!MI->isLabel())
1679           AtBlockEntry = false;
1680
1681         // First known non-DBG_VALUE and non-frame setup location marks
1682         // the beginning of the function body.
1683         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1684             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1685           PrologEndLoc = MI->getDebugLoc();
1686
1687         // Check if the instruction clobbers any registers with debug vars.
1688         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1689                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1690           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1691             continue;
1692           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1693                AI.isValid(); ++AI) {
1694             unsigned Reg = *AI;
1695             const MDNode *Var = LiveUserVar[Reg];
1696             if (!Var)
1697               continue;
1698             // Reg is now clobbered.
1699             LiveUserVar[Reg] = 0;
1700
1701             // Was MD last defined by a DBG_VALUE referring to Reg?
1702             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1703             if (HistI == DbgValues.end())
1704               continue;
1705             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1706             if (History.empty())
1707               continue;
1708             const MachineInstr *Prev = History.back();
1709             // Sanity-check: Register assignments are terminated at the end of
1710             // their block.
1711             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1712               continue;
1713             // Is the variable still in Reg?
1714             if (!isDbgValueInDefinedReg(Prev) ||
1715                 Prev->getOperand(0).getReg() != Reg)
1716               continue;
1717             // Var is clobbered. Make sure the next instruction gets a label.
1718             History.push_back(MI);
1719           }
1720         }
1721       }
1722     }
1723   }
1724
1725   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1726        I != E; ++I) {
1727     SmallVectorImpl<const MachineInstr*> &History = I->second;
1728     if (History.empty())
1729       continue;
1730
1731     // Make sure the final register assignments are terminated.
1732     const MachineInstr *Prev = History.back();
1733     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1734       const MachineBasicBlock *PrevMBB = Prev->getParent();
1735       MachineBasicBlock::const_iterator LastMI =
1736         PrevMBB->getLastNonDebugInstr();
1737       if (LastMI == PrevMBB->end())
1738         // Drop DBG_VALUE for empty range.
1739         History.pop_back();
1740       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1741         // Terminate after LastMI.
1742         History.push_back(LastMI);
1743       }
1744     }
1745     // Request labels for the full history.
1746     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1747       const MachineInstr *MI = History[i];
1748       if (MI->isDebugValue())
1749         requestLabelBeforeInsn(MI);
1750       else
1751         requestLabelAfterInsn(MI);
1752     }
1753   }
1754
1755   PrevInstLoc = DebugLoc();
1756   PrevLabel = FunctionBeginSym;
1757
1758   // Record beginning of function.
1759   if (!PrologEndLoc.isUnknown()) {
1760     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1761                                        MF->getFunction()->getContext());
1762     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1763                      FnStartDL.getScope(MF->getFunction()->getContext()),
1764     // We'd like to list the prologue as "not statements" but GDB behaves
1765     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1766                      DWARF2_FLAG_IS_STMT);
1767   }
1768 }
1769
1770 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1771   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1772   DIVariable DV = Var->getVariable();
1773   // Variables with positive arg numbers are parameters.
1774   if (unsigned ArgNum = DV.getArgNumber()) {
1775     // Keep all parameters in order at the start of the variable list to ensure
1776     // function types are correct (no out-of-order parameters)
1777     //
1778     // This could be improved by only doing it for optimized builds (unoptimized
1779     // builds have the right order to begin with), searching from the back (this
1780     // would catch the unoptimized case quickly), or doing a binary search
1781     // rather than linear search.
1782     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1783     while (I != Vars.end()) {
1784       unsigned CurNum = (*I)->getVariable().getArgNumber();
1785       // A local (non-parameter) variable has been found, insert immediately
1786       // before it.
1787       if (CurNum == 0)
1788         break;
1789       // A later indexed parameter has been found, insert immediately before it.
1790       if (CurNum > ArgNum)
1791         break;
1792       ++I;
1793     }
1794     Vars.insert(I, Var);
1795     return;
1796   }
1797
1798   Vars.push_back(Var);
1799 }
1800
1801 // Gather and emit post-function debug information.
1802 void DwarfDebug::endFunction(const MachineFunction *MF) {
1803   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1804
1805   // Define end label for subprogram.
1806   FunctionEndSym = Asm->GetTempSymbol("func_end",
1807                                       Asm->getFunctionNumber());
1808   // Assumes in correct section after the entry point.
1809   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1810   // Set DwarfCompileUnitID in MCContext to default value.
1811   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1812
1813   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1814   collectVariableInfo(MF, ProcessedVars);
1815
1816   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1817   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1818   assert(TheCU && "Unable to find compile unit!");
1819
1820   // Construct abstract scopes.
1821   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1822   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1823     LexicalScope *AScope = AList[i];
1824     DISubprogram SP(AScope->getScopeNode());
1825     if (SP.isSubprogram()) {
1826       // Collect info for variables that were optimized out.
1827       DIArray Variables = SP.getVariables();
1828       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1829         DIVariable DV(Variables.getElement(i));
1830         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1831           continue;
1832         // Check that DbgVariable for DV wasn't created earlier, when
1833         // findAbstractVariable() was called for inlined instance of DV.
1834         LLVMContext &Ctx = DV->getContext();
1835         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1836         if (AbstractVariables.lookup(CleanDV))
1837           continue;
1838         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1839           addScopeVariable(Scope, new DbgVariable(DV, NULL, this));
1840       }
1841     }
1842     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1843       constructScopeDIE(TheCU, AScope);
1844   }
1845
1846   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1847
1848   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1849     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1850
1851   // Clear debug info
1852   for (ScopeVariablesMap::iterator
1853          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1854     DeleteContainerPointers(I->second);
1855   ScopeVariables.clear();
1856   DeleteContainerPointers(CurrentFnArguments);
1857   UserVariables.clear();
1858   DbgValues.clear();
1859   AbstractVariables.clear();
1860   LabelsBeforeInsn.clear();
1861   LabelsAfterInsn.clear();
1862   PrevLabel = NULL;
1863 }
1864
1865 // Register a source line with debug info. Returns the  unique label that was
1866 // emitted and which provides correspondence to the source line list.
1867 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1868                                   unsigned Flags) {
1869   StringRef Fn;
1870   StringRef Dir;
1871   unsigned Src = 1;
1872   if (S) {
1873     DIDescriptor Scope(S);
1874
1875     if (Scope.isCompileUnit()) {
1876       DICompileUnit CU(S);
1877       Fn = CU.getFilename();
1878       Dir = CU.getDirectory();
1879     } else if (Scope.isFile()) {
1880       DIFile F(S);
1881       Fn = F.getFilename();
1882       Dir = F.getDirectory();
1883     } else if (Scope.isSubprogram()) {
1884       DISubprogram SP(S);
1885       Fn = SP.getFilename();
1886       Dir = SP.getDirectory();
1887     } else if (Scope.isLexicalBlockFile()) {
1888       DILexicalBlockFile DBF(S);
1889       Fn = DBF.getFilename();
1890       Dir = DBF.getDirectory();
1891     } else if (Scope.isLexicalBlock()) {
1892       DILexicalBlock DB(S);
1893       Fn = DB.getFilename();
1894       Dir = DB.getDirectory();
1895     } else
1896       llvm_unreachable("Unexpected scope info");
1897
1898     Src = getOrCreateSourceID(Fn, Dir,
1899             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1900   }
1901   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1902 }
1903
1904 //===----------------------------------------------------------------------===//
1905 // Emit Methods
1906 //===----------------------------------------------------------------------===//
1907
1908 // Compute the size and offset of a DIE.
1909 unsigned
1910 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1911   // Get the children.
1912   const std::vector<DIE *> &Children = Die->getChildren();
1913
1914   // Record the abbreviation.
1915   assignAbbrevNumber(Die->getAbbrev());
1916
1917   // Get the abbreviation for this DIE.
1918   unsigned AbbrevNumber = Die->getAbbrevNumber();
1919   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1920
1921   // Set DIE offset
1922   Die->setOffset(Offset);
1923
1924   // Start the size with the size of abbreviation code.
1925   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1926
1927   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1928   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1929
1930   // Size the DIE attribute values.
1931   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1932     // Size attribute value.
1933     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1934
1935   // Size the DIE children if any.
1936   if (!Children.empty()) {
1937     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1938            "Children flag not set");
1939
1940     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1941       Offset = computeSizeAndOffset(Children[j], Offset);
1942
1943     // End of children marker.
1944     Offset += sizeof(int8_t);
1945   }
1946
1947   Die->setSize(Offset - Die->getOffset());
1948   return Offset;
1949 }
1950
1951 // Compute the size and offset of all the DIEs.
1952 void DwarfUnits::computeSizeAndOffsets() {
1953   // Offset from the beginning of debug info section.
1954   unsigned SecOffset = 0;
1955   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1956          E = CUs.end(); I != E; ++I) {
1957     (*I)->setDebugInfoOffset(SecOffset);
1958     unsigned Offset =
1959       sizeof(int32_t) + // Length of Compilation Unit Info
1960       sizeof(int16_t) + // DWARF version number
1961       sizeof(int32_t) + // Offset Into Abbrev. Section
1962       sizeof(int8_t);   // Pointer Size (in bytes)
1963
1964     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1965     SecOffset += EndOffset;
1966   }
1967 }
1968
1969 // Emit initial Dwarf sections with a label at the start of each one.
1970 void DwarfDebug::emitSectionLabels() {
1971   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1972
1973   // Dwarf sections base addresses.
1974   DwarfInfoSectionSym =
1975     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1976   DwarfAbbrevSectionSym =
1977     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1978   if (useSplitDwarf())
1979     DwarfAbbrevDWOSectionSym =
1980       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1981                      "section_abbrev_dwo");
1982   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1983
1984   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1985     emitSectionSym(Asm, MacroInfo);
1986
1987   DwarfLineSectionSym =
1988     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1989   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1990   if (GenerateGnuPubSections) {
1991     DwarfGnuPubNamesSectionSym =
1992         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1993     DwarfGnuPubTypesSectionSym =
1994         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1995   } else if (HasDwarfPubSections) {
1996     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1997     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1998   }
1999
2000   DwarfStrSectionSym =
2001     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2002   if (useSplitDwarf()) {
2003     DwarfStrDWOSectionSym =
2004       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2005     DwarfAddrSectionSym =
2006       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2007   }
2008   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2009                                              "debug_range");
2010
2011   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2012                                            "section_debug_loc");
2013
2014   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2015   emitSectionSym(Asm, TLOF.getDataSection());
2016 }
2017
2018 // Recursively emits a debug information entry.
2019 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2020   // Get the abbreviation for this DIE.
2021   unsigned AbbrevNumber = Die->getAbbrevNumber();
2022   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2023
2024   // Emit the code (index) for the abbreviation.
2025   if (Asm->isVerbose())
2026     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2027                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2028                                 Twine::utohexstr(Die->getSize()) + " " +
2029                                 dwarf::TagString(Abbrev->getTag()));
2030   Asm->EmitULEB128(AbbrevNumber);
2031
2032   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2033   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2034
2035   // Emit the DIE attribute values.
2036   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2037     unsigned Attr = AbbrevData[i].getAttribute();
2038     unsigned Form = AbbrevData[i].getForm();
2039     assert(Form && "Too many attributes for DIE (check abbreviation)");
2040
2041     if (Asm->isVerbose())
2042       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2043
2044     switch (Attr) {
2045     case dwarf::DW_AT_abstract_origin:
2046     case dwarf::DW_AT_type:
2047     case dwarf::DW_AT_friend:
2048     case dwarf::DW_AT_specification:
2049     case dwarf::DW_AT_containing_type: {
2050       DIEEntry *E = cast<DIEEntry>(Values[i]);
2051       DIE *Origin = E->getEntry();
2052       unsigned Addr = Origin->getOffset();
2053       if (Form == dwarf::DW_FORM_ref_addr) {
2054         // For DW_FORM_ref_addr, output the offset from beginning of debug info
2055         // section. Origin->getOffset() returns the offset from start of the
2056         // compile unit.
2057         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2058         Addr += Holder.getCUOffset(Origin->getCompileUnit());
2059       }
2060       Asm->OutStreamer.EmitIntValue(Addr,
2061           Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2062       break;
2063     }
2064     case dwarf::DW_AT_ranges: {
2065       // DW_AT_range Value encodes offset in debug_range section.
2066       DIEInteger *V = cast<DIEInteger>(Values[i]);
2067
2068       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2069         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2070                                  V->getValue(),
2071                                  4);
2072       } else {
2073         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2074                                        V->getValue(),
2075                                        DwarfDebugRangeSectionSym,
2076                                        4);
2077       }
2078       break;
2079     }
2080     case dwarf::DW_AT_location: {
2081       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2082         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2083           Asm->EmitLabelReference(L->getValue(), 4);
2084         else
2085           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2086       } else {
2087         Values[i]->EmitValue(Asm, Form);
2088       }
2089       break;
2090     }
2091     case dwarf::DW_AT_accessibility: {
2092       if (Asm->isVerbose()) {
2093         DIEInteger *V = cast<DIEInteger>(Values[i]);
2094         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2095       }
2096       Values[i]->EmitValue(Asm, Form);
2097       break;
2098     }
2099     default:
2100       // Emit an attribute using the defined form.
2101       Values[i]->EmitValue(Asm, Form);
2102       break;
2103     }
2104   }
2105
2106   // Emit the DIE children if any.
2107   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2108     const std::vector<DIE *> &Children = Die->getChildren();
2109
2110     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2111       emitDIE(Children[j], Abbrevs);
2112
2113     if (Asm->isVerbose())
2114       Asm->OutStreamer.AddComment("End Of Children Mark");
2115     Asm->EmitInt8(0);
2116   }
2117 }
2118
2119 // Emit the various dwarf units to the unit section USection with
2120 // the abbreviations going into ASection.
2121 void DwarfUnits::emitUnits(DwarfDebug *DD,
2122                            const MCSection *USection,
2123                            const MCSection *ASection,
2124                            const MCSymbol *ASectionSym) {
2125   Asm->OutStreamer.SwitchSection(USection);
2126   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2127          E = CUs.end(); I != E; ++I) {
2128     CompileUnit *TheCU = *I;
2129     DIE *Die = TheCU->getCUDie();
2130
2131     // Emit the compile units header.
2132     Asm->OutStreamer
2133       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2134                                     TheCU->getUniqueID()));
2135
2136     // Emit size of content not including length itself
2137     unsigned ContentSize = Die->getSize() +
2138       sizeof(int16_t) + // DWARF version number
2139       sizeof(int32_t) + // Offset Into Abbrev. Section
2140       sizeof(int8_t);   // Pointer Size (in bytes)
2141
2142     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2143     Asm->EmitInt32(ContentSize);
2144     Asm->OutStreamer.AddComment("DWARF version number");
2145     Asm->EmitInt16(DD->getDwarfVersion());
2146     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2147     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2148                            ASectionSym);
2149     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2150     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2151
2152     DD->emitDIE(Die, Abbreviations);
2153     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2154                                                   TheCU->getUniqueID()));
2155   }
2156 }
2157
2158 /// For a given compile unit DIE, returns offset from beginning of debug info.
2159 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2160   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
2161          "Input DIE should be compile unit in getCUOffset.");
2162   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2163        I != E; ++I) {
2164     CompileUnit *TheCU = *I;
2165     if (TheCU->getCUDie() == Die)
2166       return TheCU->getDebugInfoOffset();
2167   }
2168   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2169 }
2170
2171 // Emit the debug info section.
2172 void DwarfDebug::emitDebugInfo() {
2173   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2174
2175   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2176                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2177                    DwarfAbbrevSectionSym);
2178 }
2179
2180 // Emit the abbreviation section.
2181 void DwarfDebug::emitAbbreviations() {
2182   if (!useSplitDwarf())
2183     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2184                 &Abbreviations);
2185   else
2186     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2187 }
2188
2189 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2190                              std::vector<DIEAbbrev *> *Abbrevs) {
2191   // Check to see if it is worth the effort.
2192   if (!Abbrevs->empty()) {
2193     // Start the debug abbrev section.
2194     Asm->OutStreamer.SwitchSection(Section);
2195
2196     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2197     Asm->OutStreamer.EmitLabel(Begin);
2198
2199     // For each abbrevation.
2200     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2201       // Get abbreviation data
2202       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2203
2204       // Emit the abbrevations code (base 1 index.)
2205       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2206
2207       // Emit the abbreviations data.
2208       Abbrev->Emit(Asm);
2209     }
2210
2211     // Mark end of abbreviations.
2212     Asm->EmitULEB128(0, "EOM(3)");
2213
2214     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2215     Asm->OutStreamer.EmitLabel(End);
2216   }
2217 }
2218
2219 // Emit the last address of the section and the end of the line matrix.
2220 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2221   // Define last address of section.
2222   Asm->OutStreamer.AddComment("Extended Op");
2223   Asm->EmitInt8(0);
2224
2225   Asm->OutStreamer.AddComment("Op size");
2226   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2227   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2228   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2229
2230   Asm->OutStreamer.AddComment("Section end label");
2231
2232   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2233                                    Asm->getDataLayout().getPointerSize());
2234
2235   // Mark end of matrix.
2236   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2237   Asm->EmitInt8(0);
2238   Asm->EmitInt8(1);
2239   Asm->EmitInt8(1);
2240 }
2241
2242 // Emit visible names into a hashed accelerator table section.
2243 void DwarfDebug::emitAccelNames() {
2244   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2245                                            dwarf::DW_FORM_data4));
2246   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2247          E = CUMap.end(); I != E; ++I) {
2248     CompileUnit *TheCU = I->second;
2249     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2250     for (StringMap<std::vector<DIE*> >::const_iterator
2251            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2252       StringRef Name = GI->getKey();
2253       const std::vector<DIE *> &Entities = GI->second;
2254       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2255              DE = Entities.end(); DI != DE; ++DI)
2256         AT.AddName(Name, (*DI));
2257     }
2258   }
2259
2260   AT.FinalizeTable(Asm, "Names");
2261   Asm->OutStreamer.SwitchSection(
2262     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2263   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2264   Asm->OutStreamer.EmitLabel(SectionBegin);
2265
2266   // Emit the full data.
2267   AT.Emit(Asm, SectionBegin, &InfoHolder);
2268 }
2269
2270 // Emit objective C classes and categories into a hashed accelerator table
2271 // section.
2272 void DwarfDebug::emitAccelObjC() {
2273   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2274                                            dwarf::DW_FORM_data4));
2275   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2276          E = CUMap.end(); I != E; ++I) {
2277     CompileUnit *TheCU = I->second;
2278     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2279     for (StringMap<std::vector<DIE*> >::const_iterator
2280            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2281       StringRef Name = GI->getKey();
2282       const std::vector<DIE *> &Entities = GI->second;
2283       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2284              DE = Entities.end(); DI != DE; ++DI)
2285         AT.AddName(Name, (*DI));
2286     }
2287   }
2288
2289   AT.FinalizeTable(Asm, "ObjC");
2290   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2291                                  .getDwarfAccelObjCSection());
2292   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2293   Asm->OutStreamer.EmitLabel(SectionBegin);
2294
2295   // Emit the full data.
2296   AT.Emit(Asm, SectionBegin, &InfoHolder);
2297 }
2298
2299 // Emit namespace dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelNamespaces() {
2301   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2302                                            dwarf::DW_FORM_data4));
2303   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2304          E = CUMap.end(); I != E; ++I) {
2305     CompileUnit *TheCU = I->second;
2306     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2307     for (StringMap<std::vector<DIE*> >::const_iterator
2308            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2309       StringRef Name = GI->getKey();
2310       const std::vector<DIE *> &Entities = GI->second;
2311       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2312              DE = Entities.end(); DI != DE; ++DI)
2313         AT.AddName(Name, (*DI));
2314     }
2315   }
2316
2317   AT.FinalizeTable(Asm, "namespac");
2318   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2319                                  .getDwarfAccelNamespaceSection());
2320   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2321   Asm->OutStreamer.EmitLabel(SectionBegin);
2322
2323   // Emit the full data.
2324   AT.Emit(Asm, SectionBegin, &InfoHolder);
2325 }
2326
2327 // Emit type dies into a hashed accelerator table.
2328 void DwarfDebug::emitAccelTypes() {
2329   std::vector<DwarfAccelTable::Atom> Atoms;
2330   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2331                                         dwarf::DW_FORM_data4));
2332   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2333                                         dwarf::DW_FORM_data2));
2334   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2335                                         dwarf::DW_FORM_data1));
2336   DwarfAccelTable AT(Atoms);
2337   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2338          E = CUMap.end(); I != E; ++I) {
2339     CompileUnit *TheCU = I->second;
2340     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2341       = TheCU->getAccelTypes();
2342     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2343            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2344       StringRef Name = GI->getKey();
2345       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2346       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2347              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2348         AT.AddName(Name, (*DI).first, (*DI).second);
2349     }
2350   }
2351
2352   AT.FinalizeTable(Asm, "types");
2353   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2354                                  .getDwarfAccelTypesSection());
2355   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2356   Asm->OutStreamer.EmitLabel(SectionBegin);
2357
2358   // Emit the full data.
2359   AT.Emit(Asm, SectionBegin, &InfoHolder);
2360 }
2361
2362 // Public name handling.
2363 // The format for the various pubnames:
2364 //
2365 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2366 // for the DIE that is named.
2367 //
2368 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2369 // into the CU and the index value is computed according to the type of value
2370 // for the DIE that is named.
2371 //
2372 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2373 // it's the offset within the debug_info/debug_types dwo section, however, the
2374 // reference in the pubname header doesn't change.
2375
2376 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2377 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2378                                                         DIE *Die) {
2379   dwarf::GDBIndexEntryLinkage Linkage =
2380       Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2381                                                 : dwarf::GIEL_STATIC;
2382
2383   switch (Die->getTag()) {
2384   case dwarf::DW_TAG_class_type:
2385   case dwarf::DW_TAG_structure_type:
2386   case dwarf::DW_TAG_union_type:
2387   case dwarf::DW_TAG_enumeration_type:
2388     return dwarf::PubIndexEntryDescriptor(
2389         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2390                               ? dwarf::GIEL_STATIC
2391                               : dwarf::GIEL_EXTERNAL);
2392   case dwarf::DW_TAG_typedef:
2393   case dwarf::DW_TAG_base_type:
2394   case dwarf::DW_TAG_subrange_type:
2395     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2396   case dwarf::DW_TAG_namespace:
2397     return dwarf::GIEK_TYPE;
2398   case dwarf::DW_TAG_subprogram:
2399     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2400   case dwarf::DW_TAG_constant:
2401   case dwarf::DW_TAG_variable:
2402     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2403   case dwarf::DW_TAG_enumerator:
2404     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2405                                           dwarf::GIEL_STATIC);
2406   default:
2407     return dwarf::GIEK_NONE;
2408   }
2409 }
2410
2411 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2412 ///
2413 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2414   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2415   const MCSection *PSec =
2416       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2417                : Asm->getObjFileLowering().getDwarfPubNamesSection();
2418
2419   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2420   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2421     CompileUnit *TheCU = I->second;
2422     unsigned ID = TheCU->getUniqueID();
2423
2424     // Start the dwarf pubnames section.
2425     Asm->OutStreamer.SwitchSection(PSec);
2426
2427     // Emit a label so we can reference the beginning of this pubname section.
2428     if (GnuStyle)
2429       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2430                                                     TheCU->getUniqueID()));
2431
2432     // Emit the header.
2433     Asm->OutStreamer.AddComment("Length of Public Names Info");
2434     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2435                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2436
2437     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2438
2439     Asm->OutStreamer.AddComment("DWARF Version");
2440     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2441
2442     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2443     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2444                            DwarfInfoSectionSym);
2445
2446     Asm->OutStreamer.AddComment("Compilation Unit Length");
2447     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2448                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2449                              4);
2450
2451     // Emit the pubnames for this compilation unit.
2452     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2453     for (StringMap<DIE*>::const_iterator
2454            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2455       const char *Name = GI->getKeyData();
2456       DIE *Entity = GI->second;
2457
2458       Asm->OutStreamer.AddComment("DIE offset");
2459       Asm->EmitInt32(Entity->getOffset());
2460
2461       if (GnuStyle) {
2462         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2463         Asm->OutStreamer.AddComment(
2464             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2465             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2466         Asm->EmitInt8(Desc.toBits());
2467       }
2468
2469       if (Asm->isVerbose())
2470         Asm->OutStreamer.AddComment("External Name");
2471       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2472     }
2473
2474     Asm->OutStreamer.AddComment("End Mark");
2475     Asm->EmitInt32(0);
2476     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2477   }
2478 }
2479
2480 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2481   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2482   const MCSection *PSec =
2483       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2484                : Asm->getObjFileLowering().getDwarfPubTypesSection();
2485
2486   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2487                                                          E = CUMap.end();
2488        I != E; ++I) {
2489     CompileUnit *TheCU = I->second;
2490     // Start the dwarf pubtypes section.
2491     Asm->OutStreamer.SwitchSection(PSec);
2492
2493     // Emit a label so we can reference the beginning of this pubtype section.
2494     if (GnuStyle)
2495       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2496                                                     TheCU->getUniqueID()));
2497
2498     // Emit the header.
2499     Asm->OutStreamer.AddComment("Length of Public Types Info");
2500     Asm->EmitLabelDifference(
2501         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2502         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2503
2504     Asm->OutStreamer.EmitLabel(
2505         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2506
2507     if (Asm->isVerbose())
2508       Asm->OutStreamer.AddComment("DWARF Version");
2509     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2510
2511     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2512     Asm->EmitSectionOffset(
2513         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2514         DwarfInfoSectionSym);
2515
2516     Asm->OutStreamer.AddComment("Compilation Unit Length");
2517     Asm->EmitLabelDifference(
2518         Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2519         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2520
2521     // Emit the pubtypes.
2522     const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2523     for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2524                                           GE = Globals.end();
2525          GI != GE; ++GI) {
2526       const char *Name = GI->getKeyData();
2527       DIE *Entity = GI->second;
2528
2529       if (Asm->isVerbose())
2530         Asm->OutStreamer.AddComment("DIE offset");
2531       Asm->EmitInt32(Entity->getOffset());
2532
2533       if (GnuStyle) {
2534         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2535         Asm->OutStreamer.AddComment(
2536             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2537             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2538         Asm->EmitInt8(Desc.toBits());
2539       }
2540
2541       if (Asm->isVerbose())
2542         Asm->OutStreamer.AddComment("External Name");
2543
2544       // Emit the name with a terminating null byte.
2545       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2546     }
2547
2548     Asm->OutStreamer.AddComment("End Mark");
2549     Asm->EmitInt32(0);
2550     Asm->OutStreamer.EmitLabel(
2551         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2552   }
2553 }
2554
2555 // Emit strings into a string section.
2556 void DwarfUnits::emitStrings(const MCSection *StrSection,
2557                              const MCSection *OffsetSection = NULL,
2558                              const MCSymbol *StrSecSym = NULL) {
2559
2560   if (StringPool.empty()) return;
2561
2562   // Start the dwarf str section.
2563   Asm->OutStreamer.SwitchSection(StrSection);
2564
2565   // Get all of the string pool entries and put them in an array by their ID so
2566   // we can sort them.
2567   SmallVector<std::pair<unsigned,
2568                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2569
2570   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2571          I = StringPool.begin(), E = StringPool.end();
2572        I != E; ++I)
2573     Entries.push_back(std::make_pair(I->second.second, &*I));
2574
2575   array_pod_sort(Entries.begin(), Entries.end());
2576
2577   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2578     // Emit a label for reference from debug information entries.
2579     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2580
2581     // Emit the string itself with a terminating null byte.
2582     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2583                                          Entries[i].second->getKeyLength()+1));
2584   }
2585
2586   // If we've got an offset section go ahead and emit that now as well.
2587   if (OffsetSection) {
2588     Asm->OutStreamer.SwitchSection(OffsetSection);
2589     unsigned offset = 0;
2590     unsigned size = 4; // FIXME: DWARF64 is 8.
2591     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2592       Asm->OutStreamer.EmitIntValue(offset, size);
2593       offset += Entries[i].second->getKeyLength() + 1;
2594     }
2595   }
2596 }
2597
2598 // Emit strings into a string section.
2599 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2600
2601   if (AddressPool.empty()) return;
2602
2603   // Start the dwarf addr section.
2604   Asm->OutStreamer.SwitchSection(AddrSection);
2605
2606   // Order the address pool entries by ID
2607   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2608
2609   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2610                                                     E = AddressPool.end();
2611        I != E; ++I)
2612     Entries[I->second] = I->first;
2613
2614   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2615     // Emit an expression for reference from debug information entries.
2616     if (const MCExpr *Expr = Entries[i])
2617       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2618     else
2619       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2620   }
2621
2622 }
2623
2624 // Emit visible names into a debug str section.
2625 void DwarfDebug::emitDebugStr() {
2626   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2627   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2628 }
2629
2630 // Emit locations into the debug loc section.
2631 void DwarfDebug::emitDebugLoc() {
2632   if (DotDebugLocEntries.empty())
2633     return;
2634
2635   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2636          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2637        I != E; ++I) {
2638     DotDebugLocEntry &Entry = *I;
2639     if (I + 1 != DotDebugLocEntries.end())
2640       Entry.Merge(I+1);
2641   }
2642
2643   // Start the dwarf loc section.
2644   Asm->OutStreamer.SwitchSection(
2645     Asm->getObjFileLowering().getDwarfLocSection());
2646   unsigned char Size = Asm->getDataLayout().getPointerSize();
2647   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2648   unsigned index = 1;
2649   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2650          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2651        I != E; ++I, ++index) {
2652     DotDebugLocEntry &Entry = *I;
2653     if (Entry.isMerged()) continue;
2654     if (Entry.isEmpty()) {
2655       Asm->OutStreamer.EmitIntValue(0, Size);
2656       Asm->OutStreamer.EmitIntValue(0, Size);
2657       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2658     } else {
2659       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2660       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2661       DIVariable DV(Entry.getVariable());
2662       Asm->OutStreamer.AddComment("Loc expr size");
2663       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2664       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2665       Asm->EmitLabelDifference(end, begin, 2);
2666       Asm->OutStreamer.EmitLabel(begin);
2667       if (Entry.isInt()) {
2668         DIBasicType BTy(DV.getType());
2669         if (BTy.Verify() &&
2670             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2671              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2672           Asm->OutStreamer.AddComment("DW_OP_consts");
2673           Asm->EmitInt8(dwarf::DW_OP_consts);
2674           Asm->EmitSLEB128(Entry.getInt());
2675         } else {
2676           Asm->OutStreamer.AddComment("DW_OP_constu");
2677           Asm->EmitInt8(dwarf::DW_OP_constu);
2678           Asm->EmitULEB128(Entry.getInt());
2679         }
2680       } else if (Entry.isLocation()) {
2681         MachineLocation Loc = Entry.getLoc();
2682         if (!DV.hasComplexAddress())
2683           // Regular entry.
2684           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2685         else {
2686           // Complex address entry.
2687           unsigned N = DV.getNumAddrElements();
2688           unsigned i = 0;
2689           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2690             if (Loc.getOffset()) {
2691               i = 2;
2692               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2693               Asm->OutStreamer.AddComment("DW_OP_deref");
2694               Asm->EmitInt8(dwarf::DW_OP_deref);
2695               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2696               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2697               Asm->EmitSLEB128(DV.getAddrElement(1));
2698             } else {
2699               // If first address element is OpPlus then emit
2700               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2701               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2702               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2703               i = 2;
2704             }
2705           } else {
2706             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2707           }
2708
2709           // Emit remaining complex address elements.
2710           for (; i < N; ++i) {
2711             uint64_t Element = DV.getAddrElement(i);
2712             if (Element == DIBuilder::OpPlus) {
2713               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2714               Asm->EmitULEB128(DV.getAddrElement(++i));
2715             } else if (Element == DIBuilder::OpDeref) {
2716               if (!Loc.isReg())
2717                 Asm->EmitInt8(dwarf::DW_OP_deref);
2718             } else
2719               llvm_unreachable("unknown Opcode found in complex address");
2720           }
2721         }
2722       }
2723       // else ... ignore constant fp. There is not any good way to
2724       // to represent them here in dwarf.
2725       Asm->OutStreamer.EmitLabel(end);
2726     }
2727   }
2728 }
2729
2730 struct SymbolCUSorter {
2731   SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2732   const MCStreamer &Streamer;
2733
2734   bool operator() (const SymbolCU &A, const SymbolCU &B) {
2735     unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2736     unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2737
2738     // Symbols with no order assigned should be placed at the end.
2739     // (e.g. section end labels)
2740     if (IA == 0)
2741       IA = (unsigned)(-1);
2742     if (IB == 0)
2743       IB = (unsigned)(-1);
2744     return IA < IB;
2745   }
2746 };
2747
2748 static bool SectionSort(const MCSection *A, const MCSection *B) {
2749     std::string LA = (A ? A->getLabelBeginName() : "");
2750     std::string LB = (B ? B->getLabelBeginName() : "");
2751     return LA < LB;
2752 }
2753
2754 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2755     return (A->getUniqueID() < B->getUniqueID());
2756 }
2757
2758 struct ArangeSpan {
2759   const MCSymbol *Start, *End;
2760 };
2761
2762 // Emit a debug aranges section, containing a CU lookup for any
2763 // address we can tie back to a CU.
2764 void DwarfDebug::emitDebugARanges() {
2765   // Start the dwarf aranges section.
2766   Asm->OutStreamer
2767       .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2768
2769   typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2770
2771   SpansType Spans;
2772
2773   // Build a list of sections used.
2774   std::vector<const MCSection *> Sections;
2775   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2776        it++) {
2777     const MCSection *Section = it->first;
2778     Sections.push_back(Section);
2779   }
2780
2781   // Sort the sections into order.
2782   // This is only done to ensure consistent output order across different runs.
2783   std::sort(Sections.begin(), Sections.end(), SectionSort);
2784
2785   // Build a set of address spans, sorted by CU.
2786   for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2787     const MCSection *Section = Sections[SecIdx];
2788     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2789     if (List.size() < 2)
2790       continue;
2791
2792     // Sort the symbols by offset within the section.
2793     SymbolCUSorter sorter(Asm->OutStreamer);
2794     std::sort(List.begin(), List.end(), sorter);
2795
2796     // If we have no section (e.g. common), just write out
2797     // individual spans for each symbol.
2798     if (Section == NULL) {
2799       for (size_t n = 0; n < List.size(); n++) {
2800         const SymbolCU &Cur = List[n];
2801
2802         ArangeSpan Span;
2803         Span.Start = Cur.Sym;
2804         Span.End = NULL;
2805         if (Cur.CU)
2806           Spans[Cur.CU].push_back(Span);
2807       }
2808     } else {
2809       // Build spans between each label.
2810       const MCSymbol *StartSym = List[0].Sym;
2811       for (size_t n = 1; n < List.size(); n++) {
2812         const SymbolCU &Prev = List[n - 1];
2813         const SymbolCU &Cur = List[n];
2814
2815         // Try and build the longest span we can within the same CU.
2816         if (Cur.CU != Prev.CU) {
2817           ArangeSpan Span;
2818           Span.Start = StartSym;
2819           Span.End = Cur.Sym;
2820           Spans[Prev.CU].push_back(Span);
2821           StartSym = Cur.Sym;
2822         }
2823       }
2824     }
2825   }
2826
2827   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2828   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2829
2830   // Build a list of CUs used.
2831   std::vector<CompileUnit *> CUs;
2832   for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2833     CompileUnit *CU = it->first;
2834     CUs.push_back(CU);
2835   }
2836
2837   // Sort the CU list (again, to ensure consistent output order).
2838   std::sort(CUs.begin(), CUs.end(), CUSort);
2839
2840   // Emit an arange table for each CU we used.
2841   for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2842     CompileUnit *CU = CUs[CUIdx];
2843     std::vector<ArangeSpan> &List = Spans[CU];
2844
2845     // Emit size of content not including length itself.
2846     unsigned ContentSize
2847         = sizeof(int16_t) // DWARF ARange version number
2848         + sizeof(int32_t) // Offset of CU in the .debug_info section
2849         + sizeof(int8_t)  // Pointer Size (in bytes)
2850         + sizeof(int8_t); // Segment Size (in bytes)
2851
2852     unsigned TupleSize = PtrSize * 2;
2853
2854     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2855     unsigned Padding = 0;
2856     while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2857       Padding++;
2858
2859     ContentSize += Padding;
2860     ContentSize += (List.size() + 1) * TupleSize;
2861
2862     // For each compile unit, write the list of spans it covers.
2863     Asm->OutStreamer.AddComment("Length of ARange Set");
2864     Asm->EmitInt32(ContentSize);
2865     Asm->OutStreamer.AddComment("DWARF Arange version number");
2866     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2867     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2868     Asm->EmitSectionOffset(
2869         Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2870         DwarfInfoSectionSym);
2871     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2872     Asm->EmitInt8(PtrSize);
2873     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2874     Asm->EmitInt8(0);
2875
2876     for (unsigned n = 0; n < Padding; n++)
2877       Asm->EmitInt8(0xff);
2878
2879     for (unsigned n = 0; n < List.size(); n++) {
2880       const ArangeSpan &Span = List[n];
2881       Asm->EmitLabelReference(Span.Start, PtrSize);
2882
2883       // Calculate the size as being from the span start to it's end.
2884       if (Span.End) {
2885         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2886       } else {
2887         // For symbols without an end marker (e.g. common), we
2888         // write a single arange entry containing just that one symbol.
2889         uint64_t Size = SymSize[Span.Start];
2890         if (Size == 0)
2891           Size = 1;
2892
2893         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2894       }
2895     }
2896
2897     Asm->OutStreamer.AddComment("ARange terminator");
2898     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2899     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2900   }
2901 }
2902
2903 // Emit visible names into a debug ranges section.
2904 void DwarfDebug::emitDebugRanges() {
2905   // Start the dwarf ranges section.
2906   Asm->OutStreamer
2907       .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2908   unsigned char Size = Asm->getDataLayout().getPointerSize();
2909   for (SmallVectorImpl<const MCSymbol *>::iterator
2910          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2911        I != E; ++I) {
2912     if (*I)
2913       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2914     else
2915       Asm->OutStreamer.EmitIntValue(0, Size);
2916   }
2917 }
2918
2919 // Emit visible names into a debug macinfo section.
2920 void DwarfDebug::emitDebugMacInfo() {
2921   if (const MCSection *LineInfo =
2922       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2923     // Start the dwarf macinfo section.
2924     Asm->OutStreamer.SwitchSection(LineInfo);
2925   }
2926 }
2927
2928 // DWARF5 Experimental Separate Dwarf emitters.
2929
2930 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2931 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2932 // DW_AT_ranges_base, DW_AT_addr_base.
2933 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2934
2935   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2936   CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2937                                        Asm, this, &SkeletonHolder);
2938
2939   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2940                         DICompileUnit(CU->getNode()).getSplitDebugFilename());
2941
2942   // Relocate to the beginning of the addr_base section, else 0 for the
2943   // beginning of the one for this compile unit.
2944   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2945     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2946                     DwarfAddrSectionSym);
2947   else
2948     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2949                    dwarf::DW_FORM_sec_offset, 0);
2950
2951   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2952   // into an entity. We're using 0, or a NULL label for this.
2953   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2954
2955   // DW_AT_stmt_list is a offset of line number information for this
2956   // compile unit in debug_line section.
2957   // FIXME: Should handle multiple compile units.
2958   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2959     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2960                     DwarfLineSectionSym);
2961   else
2962     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2963
2964   if (!CompilationDir.empty())
2965     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2966
2967   // Flags to let the linker know we have emitted new style pubnames.
2968   if (GenerateGnuPubSections) {
2969     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2970       NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2971                       Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2972     else
2973       NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2974                       Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2975                       DwarfGnuPubNamesSectionSym);
2976
2977     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2978       NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2979                       Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2980     else
2981       NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2982                       Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()),
2983                       DwarfGnuPubTypesSectionSym);
2984   }
2985
2986   // Flag if we've emitted any ranges and their location for the compile unit.
2987   if (DebugRangeSymbols.size()) {
2988     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2989       NewCU->addLabel(Die, dwarf::DW_AT_GNU_ranges_base,
2990                       dwarf::DW_FORM_sec_offset, DwarfDebugRangeSectionSym);
2991     else
2992       NewCU->addUInt(Die, dwarf::DW_AT_GNU_ranges_base, dwarf::DW_FORM_data4,
2993                      0);
2994   }
2995
2996   SkeletonHolder.addUnit(NewCU);
2997   SkeletonCUs.push_back(NewCU);
2998
2999   return NewCU;
3000 }
3001
3002 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
3003   assert(useSplitDwarf() && "No split dwarf debug info?");
3004   emitAbbrevs(Section, &SkeletonAbbrevs);
3005 }
3006
3007 // Emit the .debug_info.dwo section for separated dwarf. This contains the
3008 // compile units that would normally be in debug_info.
3009 void DwarfDebug::emitDebugInfoDWO() {
3010   assert(useSplitDwarf() && "No split dwarf debug info?");
3011   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3012                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3013                        DwarfAbbrevDWOSectionSym);
3014 }
3015
3016 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3017 // abbreviations for the .debug_info.dwo section.
3018 void DwarfDebug::emitDebugAbbrevDWO() {
3019   assert(useSplitDwarf() && "No split dwarf?");
3020   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3021               &Abbreviations);
3022 }
3023
3024 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3025 // string section and is identical in format to traditional .debug_str
3026 // sections.
3027 void DwarfDebug::emitDebugStrDWO() {
3028   assert(useSplitDwarf() && "No split dwarf?");
3029   const MCSection *OffSec = Asm->getObjFileLowering()
3030                             .getDwarfStrOffDWOSection();
3031   const MCSymbol *StrSym = DwarfStrSectionSym;
3032   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3033                          OffSec, StrSym);
3034 }
3035
3036 /// When we don't know whether the correct form is ref4 or ref_addr, we create
3037 /// a worklist item and insert it to DIEEntryWorklist.
3038 void DwarfDebug::addDIEEntry(DIE *Die, uint16_t Attribute, uint16_t Form,
3039                              DIEEntry *Entry) {
3040   /// Early exit when we only have a single CU.
3041   if (GlobalCUIndexCount == 1 || Form != dwarf::DW_FORM_ref4) {
3042     Die->addValue(Attribute, Form, Entry);
3043     return;
3044   }
3045   DIE *DieCU = Die->checkCompileUnit();
3046   DIE *EntryCU = Entry->getEntry()->checkCompileUnit();
3047   if (!DieCU || !EntryCU) {
3048     // Die or Entry is not added to an owner yet.
3049     insertDIEEntryWorklist(Die, Attribute, Entry);
3050     return;
3051   }
3052   Die->addValue(Attribute,
3053          EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
3054          Entry);
3055 }