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