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