lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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