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::ZeroOrMore, 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   if (useSplitDwarf()) {
 725     // This should be a unique identifier when we want to build .dwp files.
 726     NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
 727     // Now construct the skeleton CU associated.
 728     constructSkeletonCU(N);
 729   }
 730
 731   InfoHolder.addUnit(NewCU);
 732
 733   CUMap.insert(std::make_pair(N, NewCU));
 734   return NewCU;
 735 }
 736
 737 // Construct subprogram DIE.
 738 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
 739                                         const MDNode *N) {
 740   CompileUnit *&CURef = SPMap[N];
 741   if (CURef)
 742     return;
 743   CURef = TheCU;
 744
 745   DISubprogram SP(N);
 746   if (!SP.isDefinition())
 747     // This is a method declaration which will be handled while constructing
 748     // class type.
 749     return;
 750
 751   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 752
 753   // Add to map.
 754   TheCU->insertDIE(N, SubprogramDie);
 755
 756   // Add to context owner.
 757   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
 758
 759   // Expose as global, if requested.
 760   if (GenerateDwarfPubNamesSection)
 761     TheCU->addGlobalName(SP.getName(), SubprogramDie);
 762 }
 763
 764 // Emit all Dwarf sections that should come prior to the content. Create
 765 // global DIEs and emit initial debug info sections. This is invoked by
 766 // the target AsmPrinter.
 767 void DwarfDebug::beginModule() {
 768   if (DisableDebugInfoPrinting)
 769     return;
 770
 771   const Module *M = MMI->getModule();
 772
 773   // If module has named metadata anchors then use them, otherwise scan the
 774   // module using debug info finder to collect debug info.
 775   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 776   if (!CU_Nodes)
 777     return;
 778
 779   // Emit initial sections so we can reference labels later.
 780   emitSectionLabels();
 781
 782   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 783     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 784     CompileUnit *CU = constructCompileUnit(CUNode);
 785     DIArray GVs = CUNode.getGlobalVariables();
 786     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 787       CU->createGlobalVariableDIE(GVs.getElement(i));
 788     DIArray SPs = CUNode.getSubprograms();
 789     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 790       constructSubprogramDIE(CU, SPs.getElement(i));
 791     DIArray EnumTypes = CUNode.getEnumTypes();
 792     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 793       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 794     DIArray RetainedTypes = CUNode.getRetainedTypes();
 795     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 796       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 797   }
 798
 799   // Tell MMI that we have debug info.
 800   MMI->setDebugInfoAvailability(true);
 801
 802   // Prime section data.
 803   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 804 }
 805
 806 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 807 void DwarfDebug::computeInlinedDIEs() {
 808   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 809   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 810          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 811     DIE *ISP = *AI;
 812     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 813   }
 814   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 815          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 816     DIE *ISP = AI->second;
 817     if (InlinedSubprogramDIEs.count(ISP))
 818       continue;
 819     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 820   }
 821 }
 822
 823 // Collect info for variables that were optimized out.
 824 void DwarfDebug::collectDeadVariables() {
 825   const Module *M = MMI->getModule();
 826   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 827
 828   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 829     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 830       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 831       DIArray Subprograms = TheCU.getSubprograms();
 832       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 833         DISubprogram SP(Subprograms.getElement(i));
 834         if (ProcessedSPNodes.count(SP) != 0) continue;
 835         if (!SP.Verify()) continue;
 836         if (!SP.isDefinition()) continue;
 837         DIArray Variables = SP.getVariables();
 838         if (Variables.getNumElements() == 0) continue;
 839
 840         LexicalScope *Scope =
 841           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 842         DeadFnScopeMap[SP] = Scope;
 843
 844         // Construct subprogram DIE and add variables DIEs.
 845         CompileUnit *SPCU = CUMap.lookup(TheCU);
 846         assert(SPCU && "Unable to find Compile Unit!");
 847         constructSubprogramDIE(SPCU, SP);
 848         DIE *ScopeDIE = SPCU->getDIE(SP);
 849         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 850           DIVariable DV(Variables.getElement(vi));
 851           if (!DV.Verify()) continue;
 852           DbgVariable *NewVar = new DbgVariable(DV, NULL);
 853           if (DIE *VariableDIE =
 854               SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
 855             ScopeDIE->addChild(VariableDIE);
 856         }
 857       }
 858     }
 859   }
 860   DeleteContainerSeconds(DeadFnScopeMap);
 861 }
 862
 863 void DwarfDebug::finalizeModuleInfo() {
 864   // Collect info for variables that were optimized out.
 865   collectDeadVariables();
 866
 867   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 868   computeInlinedDIEs();
 869
 870   // Emit DW_AT_containing_type attribute to connect types with their
 871   // vtable holding type.
 872   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 873          CUE = CUMap.end(); CUI != CUE; ++CUI) {
 874     CompileUnit *TheCU = CUI->second;
 875     TheCU->constructContainingTypeDIEs();
 876   }
 877
 878    // Compute DIE offsets and sizes.
 879   InfoHolder.computeSizeAndOffsets();
 880   if (useSplitDwarf())
 881     SkeletonHolder.computeSizeAndOffsets();
 882 }
 883
 884 void DwarfDebug::endSections() {
 885   // Standard sections final addresses.
 886   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
 887   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
 888   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
 889   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
 890
 891   // End text sections.
 892   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
 893     Asm->OutStreamer.SwitchSection(SectionMap[I]);
 894     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
 895   }
 896 }
 897
 898 // Emit all Dwarf sections that should come after the content.
 899 void DwarfDebug::endModule() {
 900
 901   if (!FirstCU) return;
 902
 903   // End any existing sections.
 904   // TODO: Does this need to happen?
 905   endSections();
 906
 907   // Finalize the debug info for the module.
 908   finalizeModuleInfo();
 909
 910   if (!useSplitDwarf()) {
 911     // Emit all the DIEs into a debug info section.
 912     emitDebugInfo();
 913
 914     // Corresponding abbreviations into a abbrev section.
 915     emitAbbreviations();
 916
 917     // Emit info into a debug loc section.
 918     emitDebugLoc();
 919
 920     // Emit info into a debug aranges section.
 921     emitDebugARanges();
 922
 923     // Emit info into a debug ranges section.
 924     emitDebugRanges();
 925
 926     // Emit info into a debug macinfo section.
 927     emitDebugMacInfo();
 928
 929     // Emit inline info.
 930     // TODO: When we don't need the option anymore we
 931     // can remove all of the code that this section
 932     // depends upon.
 933     if (useDarwinGDBCompat())
 934       emitDebugInlineInfo();
 935   } else {
 936     // TODO: Fill this in for separated debug sections and separate
 937     // out information into new sections.
 938
 939     // Emit the debug info section and compile units.
 940     emitDebugInfo();
 941     emitDebugInfoDWO();
 942
 943     // Corresponding abbreviations into a abbrev section.
 944     emitAbbreviations();
 945     emitDebugAbbrevDWO();
 946
 947     // Emit info into a debug loc section.
 948     emitDebugLoc();
 949
 950     // Emit info into a debug aranges section.
 951     emitDebugARanges();
 952
 953     // Emit info into a debug ranges section.
 954     emitDebugRanges();
 955
 956     // Emit info into a debug macinfo section.
 957     emitDebugMacInfo();
 958
 959     // Emit DWO addresses.
 960     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
 961
 962     // Emit inline info.
 963     // TODO: When we don't need the option anymore we
 964     // can remove all of the code that this section
 965     // depends upon.
 966     if (useDarwinGDBCompat())
 967       emitDebugInlineInfo();
 968   }
 969
 970   // Emit info into the dwarf accelerator table sections.
 971   if (useDwarfAccelTables()) {
 972     emitAccelNames();
 973     emitAccelObjC();
 974     emitAccelNamespaces();
 975     emitAccelTypes();
 976   }
 977
 978   // Emit info into a debug pubnames section, if requested.
 979   if (GenerateDwarfPubNamesSection)
 980     emitDebugPubnames();
 981
 982   // Emit info into a debug pubtypes section.
 983   // TODO: When we don't need the option anymore we can
 984   // remove all of the code that adds to the table.
 985   if (useDarwinGDBCompat())
 986     emitDebugPubTypes();
 987
 988   // Finally emit string information into a string table.
 989   emitDebugStr();
 990   if (useSplitDwarf())
 991     emitDebugStrDWO();
 992
 993   // clean up.
 994   SPMap.clear();
 995   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
 996          E = CUMap.end(); I != E; ++I)
 997     delete I->second;
 998
 999   for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1000          E = SkeletonCUs.end(); I != E; ++I)
1001     delete *I;
1002
1003   // Reset these for the next Module if we have one.
1004   FirstCU = NULL;
1005 }
1006
1007 // Find abstract variable, if any, associated with Var.
1008 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1009                                               DebugLoc ScopeLoc) {
1010   LLVMContext &Ctx = DV->getContext();
1011   // More then one inlined variable corresponds to one abstract variable.
1012   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1013   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1014   if (AbsDbgVariable)
1015     return AbsDbgVariable;
1016
1017   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1018   if (!Scope)
1019     return NULL;
1020
1021   AbsDbgVariable = new DbgVariable(Var, NULL);
1022   addScopeVariable(Scope, AbsDbgVariable);
1023   AbstractVariables[Var] = AbsDbgVariable;
1024   return AbsDbgVariable;
1025 }
1026
1027 // If Var is a current function argument then add it to CurrentFnArguments list.
1028 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1029                                       DbgVariable *Var, LexicalScope *Scope) {
1030   if (!LScopes.isCurrentFunctionScope(Scope))
1031     return false;
1032   DIVariable DV = Var->getVariable();
1033   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1034     return false;
1035   unsigned ArgNo = DV.getArgNumber();
1036   if (ArgNo == 0)
1037     return false;
1038
1039   size_t Size = CurrentFnArguments.size();
1040   if (Size == 0)
1041     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1042   // llvm::Function argument size is not good indicator of how many
1043   // arguments does the function have at source level.
1044   if (ArgNo > Size)
1045     CurrentFnArguments.resize(ArgNo * 2);
1046   CurrentFnArguments[ArgNo - 1] = Var;
1047   return true;
1048 }
1049
1050 // Collect variable information from side table maintained by MMI.
1051 void
1052 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1053                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1054   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1055   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1056          VE = VMap.end(); VI != VE; ++VI) {
1057     const MDNode *Var = VI->first;
1058     if (!Var) continue;
1059     Processed.insert(Var);
1060     DIVariable DV(Var);
1061     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1062
1063     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1064
1065     // If variable scope is not found then skip this variable.
1066     if (Scope == 0)
1067       continue;
1068
1069     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1070     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1071     RegVar->setFrameIndex(VP.first);
1072     if (!addCurrentFnArgument(MF, RegVar, Scope))
1073       addScopeVariable(Scope, RegVar);
1074     if (AbsDbgVariable)
1075       AbsDbgVariable->setFrameIndex(VP.first);
1076   }
1077 }
1078
1079 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1080 // defined reg.
1081 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1082   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1083   return MI->getNumOperands() == 3 &&
1084          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1085          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1086 }
1087
1088 // Get .debug_loc entry for the instruction range starting at MI.
1089 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1090                                          const MCSymbol *FLabel,
1091                                          const MCSymbol *SLabel,
1092                                          const MachineInstr *MI) {
1093   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1094
1095   if (MI->getNumOperands() != 3) {
1096     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1097     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1098   }
1099   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1100     MachineLocation MLoc;
1101     MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1102     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1103   }
1104   if (MI->getOperand(0).isImm())
1105     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1106   if (MI->getOperand(0).isFPImm())
1107     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1108   if (MI->getOperand(0).isCImm())
1109     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1110
1111   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1112 }
1113
1114 // Find variables for each lexical scope.
1115 void
1116 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1117                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1118
1119   // collection info from MMI table.
1120   collectVariableInfoFromMMITable(MF, Processed);
1121
1122   for (SmallVectorImpl<const MDNode*>::const_iterator
1123          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1124          ++UVI) {
1125     const MDNode *Var = *UVI;
1126     if (Processed.count(Var))
1127       continue;
1128
1129     // History contains relevant DBG_VALUE instructions for Var and instructions
1130     // clobbering it.
1131     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1132     if (History.empty())
1133       continue;
1134     const MachineInstr *MInsn = History.front();
1135
1136     DIVariable DV(Var);
1137     LexicalScope *Scope = NULL;
1138     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1139         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1140       Scope = LScopes.getCurrentFunctionScope();
1141     else if (MDNode *IA = DV.getInlinedAt())
1142       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1143     else
1144       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1145     // If variable scope is not found then skip this variable.
1146     if (!Scope)
1147       continue;
1148
1149     Processed.insert(DV);
1150     assert(MInsn->isDebugValue() && "History must begin with debug value");
1151     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1152     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1153     if (!addCurrentFnArgument(MF, RegVar, Scope))
1154       addScopeVariable(Scope, RegVar);
1155     if (AbsVar)
1156       AbsVar->setMInsn(MInsn);
1157
1158     // Simplify ranges that are fully coalesced.
1159     if (History.size() <= 1 || (History.size() == 2 &&
1160                                 MInsn->isIdenticalTo(History.back()))) {
1161       RegVar->setMInsn(MInsn);
1162       continue;
1163     }
1164
1165     // Handle multiple DBG_VALUE instructions describing one variable.
1166     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1167
1168     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1169            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1170       const MachineInstr *Begin = *HI;
1171       assert(Begin->isDebugValue() && "Invalid History entry");
1172
1173       // Check if DBG_VALUE is truncating a range.
1174       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1175           && !Begin->getOperand(0).getReg())
1176         continue;
1177
1178       // Compute the range for a register location.
1179       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1180       const MCSymbol *SLabel = 0;
1181
1182       if (HI + 1 == HE)
1183         // If Begin is the last instruction in History then its value is valid
1184         // until the end of the function.
1185         SLabel = FunctionEndSym;
1186       else {
1187         const MachineInstr *End = HI[1];
1188         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1189               << "\t" << *Begin << "\t" << *End << "\n");
1190         if (End->isDebugValue())
1191           SLabel = getLabelBeforeInsn(End);
1192         else {
1193           // End is a normal instruction clobbering the range.
1194           SLabel = getLabelAfterInsn(End);
1195           assert(SLabel && "Forgot label after clobber instruction");
1196           ++HI;
1197         }
1198       }
1199
1200       // The value is valid until the next DBG_VALUE or clobber.
1201       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1202                                                     Begin));
1203     }
1204     DotDebugLocEntries.push_back(DotDebugLocEntry());
1205   }
1206
1207   // Collect info for variables that were optimized out.
1208   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1209   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1210   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1211     DIVariable DV(Variables.getElement(i));
1212     if (!DV || !DV.Verify() || !Processed.insert(DV))
1213       continue;
1214     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1215       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1216   }
1217 }
1218
1219 // Return Label preceding the instruction.
1220 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1221   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1222   assert(Label && "Didn't insert label before instruction");
1223   return Label;
1224 }
1225
1226 // Return Label immediately following the instruction.
1227 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1228   return LabelsAfterInsn.lookup(MI);
1229 }
1230
1231 // Process beginning of an instruction.
1232 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1233   // Check if source location changes, but ignore DBG_VALUE locations.
1234   if (!MI->isDebugValue()) {
1235     DebugLoc DL = MI->getDebugLoc();
1236     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1237       unsigned Flags = 0;
1238       PrevInstLoc = DL;
1239       if (DL == PrologEndLoc) {
1240         Flags |= DWARF2_FLAG_PROLOGUE_END;
1241         PrologEndLoc = DebugLoc();
1242       }
1243       if (PrologEndLoc.isUnknown())
1244         Flags |= DWARF2_FLAG_IS_STMT;
1245
1246       if (!DL.isUnknown()) {
1247         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1248         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1249       } else
1250         recordSourceLine(0, 0, 0, 0);
1251     }
1252   }
1253
1254   // Insert labels where requested.
1255   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1256     LabelsBeforeInsn.find(MI);
1257
1258   // No label needed.
1259   if (I == LabelsBeforeInsn.end())
1260     return;
1261
1262   // Label already assigned.
1263   if (I->second)
1264     return;
1265
1266   if (!PrevLabel) {
1267     PrevLabel = MMI->getContext().CreateTempSymbol();
1268     Asm->OutStreamer.EmitLabel(PrevLabel);
1269   }
1270   I->second = PrevLabel;
1271 }
1272
1273 // Process end of an instruction.
1274 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1275   // Don't create a new label after DBG_VALUE instructions.
1276   // They don't generate code.
1277   if (!MI->isDebugValue())
1278     PrevLabel = 0;
1279
1280   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1281     LabelsAfterInsn.find(MI);
1282
1283   // No label needed.
1284   if (I == LabelsAfterInsn.end())
1285     return;
1286
1287   // Label already assigned.
1288   if (I->second)
1289     return;
1290
1291   // We need a label after this instruction.
1292   if (!PrevLabel) {
1293     PrevLabel = MMI->getContext().CreateTempSymbol();
1294     Asm->OutStreamer.EmitLabel(PrevLabel);
1295   }
1296   I->second = PrevLabel;
1297 }
1298
1299 // Each LexicalScope has first instruction and last instruction to mark
1300 // beginning and end of a scope respectively. Create an inverse map that list
1301 // scopes starts (and ends) with an instruction. One instruction may start (or
1302 // end) multiple scopes. Ignore scopes that are not reachable.
1303 void DwarfDebug::identifyScopeMarkers() {
1304   SmallVector<LexicalScope *, 4> WorkList;
1305   WorkList.push_back(LScopes.getCurrentFunctionScope());
1306   while (!WorkList.empty()) {
1307     LexicalScope *S = WorkList.pop_back_val();
1308
1309     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1310     if (!Children.empty())
1311       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1312              SE = Children.end(); SI != SE; ++SI)
1313         WorkList.push_back(*SI);
1314
1315     if (S->isAbstractScope())
1316       continue;
1317
1318     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1319     if (Ranges.empty())
1320       continue;
1321     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1322            RE = Ranges.end(); RI != RE; ++RI) {
1323       assert(RI->first && "InsnRange does not have first instruction!");
1324       assert(RI->second && "InsnRange does not have second instruction!");
1325       requestLabelBeforeInsn(RI->first);
1326       requestLabelAfterInsn(RI->second);
1327     }
1328   }
1329 }
1330
1331 // Get MDNode for DebugLoc's scope.
1332 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1333   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1334     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1335   return DL.getScope(Ctx);
1336 }
1337
1338 // Walk up the scope chain of given debug loc and find line number info
1339 // for the function.
1340 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1341   const MDNode *Scope = getScopeNode(DL, Ctx);
1342   DISubprogram SP = getDISubprogram(Scope);
1343   if (SP.Verify()) {
1344     // Check for number of operands since the compatibility is
1345     // cheap here.
1346     if (SP->getNumOperands() > 19)
1347       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1348     else
1349       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1350   }
1351
1352   return DebugLoc();
1353 }
1354
1355 // Gather pre-function debug information.  Assumes being called immediately
1356 // after the function entry point has been emitted.
1357 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1358   if (!MMI->hasDebugInfo()) return;
1359   LScopes.initialize(*MF);
1360   if (LScopes.empty()) return;
1361   identifyScopeMarkers();
1362
1363   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1364   // belongs to.
1365   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1366   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1367   assert(TheCU && "Unable to find compile unit!");
1368   Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1369
1370   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1371                                         Asm->getFunctionNumber());
1372   // Assumes in correct section after the entry point.
1373   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1374
1375   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1376
1377   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1378   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1379   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1380
1381   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1382        I != E; ++I) {
1383     bool AtBlockEntry = true;
1384     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1385          II != IE; ++II) {
1386       const MachineInstr *MI = II;
1387
1388       if (MI->isDebugValue()) {
1389         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1390
1391         // Keep track of user variables.
1392         const MDNode *Var =
1393           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1394
1395         // Variable is in a register, we need to check for clobbers.
1396         if (isDbgValueInDefinedReg(MI))
1397           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1398
1399         // Check the history of this variable.
1400         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1401         if (History.empty()) {
1402           UserVariables.push_back(Var);
1403           // The first mention of a function argument gets the FunctionBeginSym
1404           // label, so arguments are visible when breaking at function entry.
1405           DIVariable DV(Var);
1406           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1407               DISubprogram(getDISubprogram(DV.getContext()))
1408                 .describes(MF->getFunction()))
1409             LabelsBeforeInsn[MI] = FunctionBeginSym;
1410         } else {
1411           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1412           const MachineInstr *Prev = History.back();
1413           if (Prev->isDebugValue()) {
1414             // Coalesce identical entries at the end of History.
1415             if (History.size() >= 2 &&
1416                 Prev->isIdenticalTo(History[History.size() - 2])) {
1417               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1418                     << "\t" << *Prev
1419                     << "\t" << *History[History.size() - 2] << "\n");
1420               History.pop_back();
1421             }
1422
1423             // Terminate old register assignments that don't reach MI;
1424             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1425             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1426                 isDbgValueInDefinedReg(Prev)) {
1427               // Previous register assignment needs to terminate at the end of
1428               // its basic block.
1429               MachineBasicBlock::const_iterator LastMI =
1430                 PrevMBB->getLastNonDebugInstr();
1431               if (LastMI == PrevMBB->end()) {
1432                 // Drop DBG_VALUE for empty range.
1433                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1434                       << "\t" << *Prev << "\n");
1435                 History.pop_back();
1436               }
1437               else {
1438                 // Terminate after LastMI.
1439                 History.push_back(LastMI);
1440               }
1441             }
1442           }
1443         }
1444         History.push_back(MI);
1445       } else {
1446         // Not a DBG_VALUE instruction.
1447         if (!MI->isLabel())
1448           AtBlockEntry = false;
1449
1450         // First known non-DBG_VALUE and non-frame setup location marks
1451         // the beginning of the function body.
1452         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1453             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1454           PrologEndLoc = MI->getDebugLoc();
1455
1456         // Check if the instruction clobbers any registers with debug vars.
1457         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1458                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1459           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1460             continue;
1461           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1462                AI.isValid(); ++AI) {
1463             unsigned Reg = *AI;
1464             const MDNode *Var = LiveUserVar[Reg];
1465             if (!Var)
1466               continue;
1467             // Reg is now clobbered.
1468             LiveUserVar[Reg] = 0;
1469
1470             // Was MD last defined by a DBG_VALUE referring to Reg?
1471             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1472             if (HistI == DbgValues.end())
1473               continue;
1474             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1475             if (History.empty())
1476               continue;
1477             const MachineInstr *Prev = History.back();
1478             // Sanity-check: Register assignments are terminated at the end of
1479             // their block.
1480             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1481               continue;
1482             // Is the variable still in Reg?
1483             if (!isDbgValueInDefinedReg(Prev) ||
1484                 Prev->getOperand(0).getReg() != Reg)
1485               continue;
1486             // Var is clobbered. Make sure the next instruction gets a label.
1487             History.push_back(MI);
1488           }
1489         }
1490       }
1491     }
1492   }
1493
1494   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1495        I != E; ++I) {
1496     SmallVectorImpl<const MachineInstr*> &History = I->second;
1497     if (History.empty())
1498       continue;
1499
1500     // Make sure the final register assignments are terminated.
1501     const MachineInstr *Prev = History.back();
1502     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1503       const MachineBasicBlock *PrevMBB = Prev->getParent();
1504       MachineBasicBlock::const_iterator LastMI =
1505         PrevMBB->getLastNonDebugInstr();
1506       if (LastMI == PrevMBB->end())
1507         // Drop DBG_VALUE for empty range.
1508         History.pop_back();
1509       else {
1510         // Terminate after LastMI.
1511         History.push_back(LastMI);
1512       }
1513     }
1514     // Request labels for the full history.
1515     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1516       const MachineInstr *MI = History[i];
1517       if (MI->isDebugValue())
1518         requestLabelBeforeInsn(MI);
1519       else
1520         requestLabelAfterInsn(MI);
1521     }
1522   }
1523
1524   PrevInstLoc = DebugLoc();
1525   PrevLabel = FunctionBeginSym;
1526
1527   // Record beginning of function.
1528   if (!PrologEndLoc.isUnknown()) {
1529     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1530                                        MF->getFunction()->getContext());
1531     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1532                      FnStartDL.getScope(MF->getFunction()->getContext()),
1533     // We'd like to list the prologue as "not statements" but GDB behaves
1534     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1535                      DWARF2_FLAG_IS_STMT);
1536   }
1537 }
1538
1539 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1540 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1541   ScopeVariables[LS].push_back(Var);
1542 //  Vars.push_back(Var);
1543 }
1544
1545 // Gather and emit post-function debug information.
1546 void DwarfDebug::endFunction(const MachineFunction *MF) {
1547   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1548
1549   // Define end label for subprogram.
1550   FunctionEndSym = Asm->GetTempSymbol("func_end",
1551                                       Asm->getFunctionNumber());
1552   // Assumes in correct section after the entry point.
1553   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1554   // Set DwarfCompileUnitID in MCContext to default value.
1555   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1556
1557   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1558   collectVariableInfo(MF, ProcessedVars);
1559
1560   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1561   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1562   assert(TheCU && "Unable to find compile unit!");
1563
1564   // Construct abstract scopes.
1565   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1566   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1567     LexicalScope *AScope = AList[i];
1568     DISubprogram SP(AScope->getScopeNode());
1569     if (SP.Verify()) {
1570       // Collect info for variables that were optimized out.
1571       DIArray Variables = SP.getVariables();
1572       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1573         DIVariable DV(Variables.getElement(i));
1574         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1575           continue;
1576         // Check that DbgVariable for DV wasn't created earlier, when
1577         // findAbstractVariable() was called for inlined instance of DV.
1578         LLVMContext &Ctx = DV->getContext();
1579         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1580         if (AbstractVariables.lookup(CleanDV))
1581           continue;
1582         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1583           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1584       }
1585     }
1586     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1587       constructScopeDIE(TheCU, AScope);
1588   }
1589
1590   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1591
1592   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1593     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1594
1595   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1596                                                MMI->getFrameMoves()));
1597
1598   // Clear debug info
1599   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1600          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1601     DeleteContainerPointers(I->second);
1602   ScopeVariables.clear();
1603   DeleteContainerPointers(CurrentFnArguments);
1604   UserVariables.clear();
1605   DbgValues.clear();
1606   AbstractVariables.clear();
1607   LabelsBeforeInsn.clear();
1608   LabelsAfterInsn.clear();
1609   PrevLabel = NULL;
1610 }
1611
1612 // Register a source line with debug info. Returns the  unique label that was
1613 // emitted and which provides correspondence to the source line list.
1614 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1615                                   unsigned Flags) {
1616   StringRef Fn;
1617   StringRef Dir;
1618   unsigned Src = 1;
1619   if (S) {
1620     DIDescriptor Scope(S);
1621
1622     if (Scope.isCompileUnit()) {
1623       DICompileUnit CU(S);
1624       Fn = CU.getFilename();
1625       Dir = CU.getDirectory();
1626     } else if (Scope.isFile()) {
1627       DIFile F(S);
1628       Fn = F.getFilename();
1629       Dir = F.getDirectory();
1630     } else if (Scope.isSubprogram()) {
1631       DISubprogram SP(S);
1632       Fn = SP.getFilename();
1633       Dir = SP.getDirectory();
1634     } else if (Scope.isLexicalBlockFile()) {
1635       DILexicalBlockFile DBF(S);
1636       Fn = DBF.getFilename();
1637       Dir = DBF.getDirectory();
1638     } else if (Scope.isLexicalBlock()) {
1639       DILexicalBlock DB(S);
1640       Fn = DB.getFilename();
1641       Dir = DB.getDirectory();
1642     } else
1643       llvm_unreachable("Unexpected scope info");
1644
1645     Src = getOrCreateSourceID(Fn, Dir,
1646             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1647   }
1648   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1649 }
1650
1651 //===----------------------------------------------------------------------===//
1652 // Emit Methods
1653 //===----------------------------------------------------------------------===//
1654
1655 // Compute the size and offset of a DIE.
1656 unsigned
1657 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1658   // Get the children.
1659   const std::vector<DIE *> &Children = Die->getChildren();
1660
1661   // Record the abbreviation.
1662   assignAbbrevNumber(Die->getAbbrev());
1663
1664   // Get the abbreviation for this DIE.
1665   unsigned AbbrevNumber = Die->getAbbrevNumber();
1666   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1667
1668   // Set DIE offset
1669   Die->setOffset(Offset);
1670
1671   // Start the size with the size of abbreviation code.
1672   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1673
1674   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1675   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1676
1677   // Size the DIE attribute values.
1678   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1679     // Size attribute value.
1680     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1681
1682   // Size the DIE children if any.
1683   if (!Children.empty()) {
1684     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1685            "Children flag not set");
1686
1687     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1688       Offset = computeSizeAndOffset(Children[j], Offset);
1689
1690     // End of children marker.
1691     Offset += sizeof(int8_t);
1692   }
1693
1694   Die->setSize(Offset - Die->getOffset());
1695   return Offset;
1696 }
1697
1698 // Compute the size and offset of all the DIEs.
1699 void DwarfUnits::computeSizeAndOffsets() {
1700   // Offset from the beginning of debug info section.
1701   unsigned AccuOffset = 0;
1702   for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1703          E = CUs.end(); I != E; ++I) {
1704     (*I)->setDebugInfoOffset(AccuOffset);
1705     unsigned Offset =
1706       sizeof(int32_t) + // Length of Compilation Unit Info
1707       sizeof(int16_t) + // DWARF version number
1708       sizeof(int32_t) + // Offset Into Abbrev. Section
1709       sizeof(int8_t);   // Pointer Size (in bytes)
1710
1711     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1712     AccuOffset += EndOffset;
1713   }
1714 }
1715
1716 // Emit initial Dwarf sections with a label at the start of each one.
1717 void DwarfDebug::emitSectionLabels() {
1718   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1719
1720   // Dwarf sections base addresses.
1721   DwarfInfoSectionSym =
1722     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1723   DwarfAbbrevSectionSym =
1724     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1725   if (useSplitDwarf())
1726     DwarfAbbrevDWOSectionSym =
1727       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1728                      "section_abbrev_dwo");
1729   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1730
1731   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1732     emitSectionSym(Asm, MacroInfo);
1733
1734   DwarfLineSectionSym =
1735     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1736   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1737   if (GenerateDwarfPubNamesSection)
1738     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1739   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1740   DwarfStrSectionSym =
1741     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1742   if (useSplitDwarf())
1743     DwarfStrDWOSectionSym =
1744       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1745   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1746                                              "debug_range");
1747
1748   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1749                                            "section_debug_loc");
1750
1751   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1752   emitSectionSym(Asm, TLOF.getDataSection());
1753 }
1754
1755 // Recursively emits a debug information entry.
1756 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1757   // Get the abbreviation for this DIE.
1758   unsigned AbbrevNumber = Die->getAbbrevNumber();
1759   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1760
1761   // Emit the code (index) for the abbreviation.
1762   if (Asm->isVerbose())
1763     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1764                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1765                                 Twine::utohexstr(Die->getSize()) + " " +
1766                                 dwarf::TagString(Abbrev->getTag()));
1767   Asm->EmitULEB128(AbbrevNumber);
1768
1769   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1770   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1771
1772   // Emit the DIE attribute values.
1773   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1774     unsigned Attr = AbbrevData[i].getAttribute();
1775     unsigned Form = AbbrevData[i].getForm();
1776     assert(Form && "Too many attributes for DIE (check abbreviation)");
1777
1778     if (Asm->isVerbose())
1779       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1780
1781     switch (Attr) {
1782     case dwarf::DW_AT_abstract_origin: {
1783       DIEEntry *E = cast<DIEEntry>(Values[i]);
1784       DIE *Origin = E->getEntry();
1785       unsigned Addr = Origin->getOffset();
1786       if (Form == dwarf::DW_FORM_ref_addr) {
1787         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1788         // section. Origin->getOffset() returns the offset from start of the
1789         // compile unit.
1790         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1791         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1792       }
1793       Asm->EmitInt32(Addr);
1794       break;
1795     }
1796     case dwarf::DW_AT_ranges: {
1797       // DW_AT_range Value encodes offset in debug_range section.
1798       DIEInteger *V = cast<DIEInteger>(Values[i]);
1799
1800       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1801         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1802                                  V->getValue(),
1803                                  4);
1804       } else {
1805         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1806                                        V->getValue(),
1807                                        DwarfDebugRangeSectionSym,
1808                                        4);
1809       }
1810       break;
1811     }
1812     case dwarf::DW_AT_location: {
1813       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1814         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1815           Asm->EmitLabelReference(L->getValue(), 4);
1816         else
1817           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1818       } else {
1819         Values[i]->EmitValue(Asm, Form);
1820       }
1821       break;
1822     }
1823     case dwarf::DW_AT_accessibility: {
1824       if (Asm->isVerbose()) {
1825         DIEInteger *V = cast<DIEInteger>(Values[i]);
1826         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1827       }
1828       Values[i]->EmitValue(Asm, Form);
1829       break;
1830     }
1831     default:
1832       // Emit an attribute using the defined form.
1833       Values[i]->EmitValue(Asm, Form);
1834       break;
1835     }
1836   }
1837
1838   // Emit the DIE children if any.
1839   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1840     const std::vector<DIE *> &Children = Die->getChildren();
1841
1842     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1843       emitDIE(Children[j], Abbrevs);
1844
1845     if (Asm->isVerbose())
1846       Asm->OutStreamer.AddComment("End Of Children Mark");
1847     Asm->EmitInt8(0);
1848   }
1849 }
1850
1851 // Emit the various dwarf units to the unit section USection with
1852 // the abbreviations going into ASection.
1853 void DwarfUnits::emitUnits(DwarfDebug *DD,
1854                            const MCSection *USection,
1855                            const MCSection *ASection,
1856                            const MCSymbol *ASectionSym) {
1857   Asm->OutStreamer.SwitchSection(USection);
1858   for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1859          E = CUs.end(); I != E; ++I) {
1860     CompileUnit *TheCU = *I;
1861     DIE *Die = TheCU->getCUDie();
1862
1863     // Emit the compile units header.
1864     Asm->OutStreamer
1865       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1866                                     TheCU->getUniqueID()));
1867
1868     // Emit size of content not including length itself
1869     unsigned ContentSize = Die->getSize() +
1870       sizeof(int16_t) + // DWARF version number
1871       sizeof(int32_t) + // Offset Into Abbrev. Section
1872       sizeof(int8_t);   // Pointer Size (in bytes)
1873
1874     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1875     Asm->EmitInt32(ContentSize);
1876     Asm->OutStreamer.AddComment("DWARF version number");
1877     Asm->EmitInt16(dwarf::DWARF_VERSION);
1878     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1879     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1880                            ASectionSym);
1881     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1882     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1883
1884     DD->emitDIE(Die, Abbreviations);
1885     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1886                                                   TheCU->getUniqueID()));
1887   }
1888 }
1889
1890 /// For a given compile unit DIE, returns offset from beginning of debug info.
1891 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1892   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
1893          "Input DIE should be compile unit in getCUOffset.");
1894   for (SmallVector<CompileUnit *, 1>::iterator I = CUs.begin(),
1895        E = CUs.end(); I != E; ++I) {
1896     CompileUnit *TheCU = *I;
1897     if (TheCU->getCUDie() == Die)
1898       return TheCU->getDebugInfoOffset();
1899   }
1900   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1901 }
1902
1903 // Emit the debug info section.
1904 void DwarfDebug::emitDebugInfo() {
1905   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1906
1907   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1908                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
1909                    DwarfAbbrevSectionSym);
1910 }
1911
1912 // Emit the abbreviation section.
1913 void DwarfDebug::emitAbbreviations() {
1914   if (!useSplitDwarf())
1915     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1916                 &Abbreviations);
1917   else
1918     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1919 }
1920
1921 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1922                              std::vector<DIEAbbrev *> *Abbrevs) {
1923   // Check to see if it is worth the effort.
1924   if (!Abbrevs->empty()) {
1925     // Start the debug abbrev section.
1926     Asm->OutStreamer.SwitchSection(Section);
1927
1928     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1929     Asm->OutStreamer.EmitLabel(Begin);
1930
1931     // For each abbrevation.
1932     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1933       // Get abbreviation data
1934       const DIEAbbrev *Abbrev = Abbrevs->at(i);
1935
1936       // Emit the abbrevations code (base 1 index.)
1937       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1938
1939       // Emit the abbreviations data.
1940       Abbrev->Emit(Asm);
1941     }
1942
1943     // Mark end of abbreviations.
1944     Asm->EmitULEB128(0, "EOM(3)");
1945
1946     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1947     Asm->OutStreamer.EmitLabel(End);
1948   }
1949 }
1950
1951 // Emit the last address of the section and the end of the line matrix.
1952 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1953   // Define last address of section.
1954   Asm->OutStreamer.AddComment("Extended Op");
1955   Asm->EmitInt8(0);
1956
1957   Asm->OutStreamer.AddComment("Op size");
1958   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1959   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1960   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1961
1962   Asm->OutStreamer.AddComment("Section end label");
1963
1964   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1965                                    Asm->getDataLayout().getPointerSize());
1966
1967   // Mark end of matrix.
1968   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1969   Asm->EmitInt8(0);
1970   Asm->EmitInt8(1);
1971   Asm->EmitInt8(1);
1972 }
1973
1974 // Emit visible names into a hashed accelerator table section.
1975 void DwarfDebug::emitAccelNames() {
1976   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1977                                            dwarf::DW_FORM_data4));
1978   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1979          E = CUMap.end(); I != E; ++I) {
1980     CompileUnit *TheCU = I->second;
1981     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1982     for (StringMap<std::vector<DIE*> >::const_iterator
1983            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1984       const char *Name = GI->getKeyData();
1985       const std::vector<DIE *> &Entities = GI->second;
1986       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1987              DE = Entities.end(); DI != DE; ++DI)
1988         AT.AddName(Name, (*DI));
1989     }
1990   }
1991
1992   AT.FinalizeTable(Asm, "Names");
1993   Asm->OutStreamer.SwitchSection(
1994     Asm->getObjFileLowering().getDwarfAccelNamesSection());
1995   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1996   Asm->OutStreamer.EmitLabel(SectionBegin);
1997
1998   // Emit the full data.
1999   AT.Emit(Asm, SectionBegin, &InfoHolder);
2000 }
2001
2002 // Emit objective C classes and categories into a hashed accelerator table
2003 // section.
2004 void DwarfDebug::emitAccelObjC() {
2005   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2006                                            dwarf::DW_FORM_data4));
2007   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2008          E = CUMap.end(); I != E; ++I) {
2009     CompileUnit *TheCU = I->second;
2010     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2011     for (StringMap<std::vector<DIE*> >::const_iterator
2012            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2013       const char *Name = GI->getKeyData();
2014       const std::vector<DIE *> &Entities = GI->second;
2015       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2016              DE = Entities.end(); DI != DE; ++DI)
2017         AT.AddName(Name, (*DI));
2018     }
2019   }
2020
2021   AT.FinalizeTable(Asm, "ObjC");
2022   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2023                                  .getDwarfAccelObjCSection());
2024   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2025   Asm->OutStreamer.EmitLabel(SectionBegin);
2026
2027   // Emit the full data.
2028   AT.Emit(Asm, SectionBegin, &InfoHolder);
2029 }
2030
2031 // Emit namespace dies into a hashed accelerator table.
2032 void DwarfDebug::emitAccelNamespaces() {
2033   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2034                                            dwarf::DW_FORM_data4));
2035   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2036          E = CUMap.end(); I != E; ++I) {
2037     CompileUnit *TheCU = I->second;
2038     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2039     for (StringMap<std::vector<DIE*> >::const_iterator
2040            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2041       const char *Name = GI->getKeyData();
2042       const std::vector<DIE *> &Entities = GI->second;
2043       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2044              DE = Entities.end(); DI != DE; ++DI)
2045         AT.AddName(Name, (*DI));
2046     }
2047   }
2048
2049   AT.FinalizeTable(Asm, "namespac");
2050   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2051                                  .getDwarfAccelNamespaceSection());
2052   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2053   Asm->OutStreamer.EmitLabel(SectionBegin);
2054
2055   // Emit the full data.
2056   AT.Emit(Asm, SectionBegin, &InfoHolder);
2057 }
2058
2059 // Emit type dies into a hashed accelerator table.
2060 void DwarfDebug::emitAccelTypes() {
2061   std::vector<DwarfAccelTable::Atom> Atoms;
2062   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2063                                         dwarf::DW_FORM_data4));
2064   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2065                                         dwarf::DW_FORM_data2));
2066   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2067                                         dwarf::DW_FORM_data1));
2068   DwarfAccelTable AT(Atoms);
2069   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2070          E = CUMap.end(); I != E; ++I) {
2071     CompileUnit *TheCU = I->second;
2072     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2073       = TheCU->getAccelTypes();
2074     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2075            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2076       const char *Name = GI->getKeyData();
2077       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2078       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2079              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2080         AT.AddName(Name, (*DI).first, (*DI).second);
2081     }
2082   }
2083
2084   AT.FinalizeTable(Asm, "types");
2085   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2086                                  .getDwarfAccelTypesSection());
2087   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2088   Asm->OutStreamer.EmitLabel(SectionBegin);
2089
2090   // Emit the full data.
2091   AT.Emit(Asm, SectionBegin, &InfoHolder);
2092 }
2093
2094 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2095 ///
2096 void DwarfDebug::emitDebugPubnames() {
2097   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2098
2099   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2100   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2101     CompileUnit *TheCU = I->second;
2102     unsigned ID = TheCU->getUniqueID();
2103
2104     if (TheCU->getGlobalNames().empty())
2105       continue;
2106
2107     // Start the dwarf pubnames section.
2108     Asm->OutStreamer.SwitchSection(
2109       Asm->getObjFileLowering().getDwarfPubNamesSection());
2110
2111     Asm->OutStreamer.AddComment("Length of Public Names Info");
2112     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2113                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2114
2115     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2116
2117     Asm->OutStreamer.AddComment("DWARF Version");
2118     Asm->EmitInt16(dwarf::DWARF_VERSION);
2119
2120     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2121     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2122                            DwarfInfoSectionSym);
2123
2124     Asm->OutStreamer.AddComment("Compilation Unit Length");
2125     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2126                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2127                              4);
2128
2129     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2130     for (StringMap<DIE*>::const_iterator
2131            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2132       const char *Name = GI->getKeyData();
2133       const DIE *Entity = GI->second;
2134
2135       Asm->OutStreamer.AddComment("DIE offset");
2136       Asm->EmitInt32(Entity->getOffset());
2137
2138       if (Asm->isVerbose())
2139         Asm->OutStreamer.AddComment("External Name");
2140       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2141     }
2142
2143     Asm->OutStreamer.AddComment("End Mark");
2144     Asm->EmitInt32(0);
2145     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2146   }
2147 }
2148
2149 void DwarfDebug::emitDebugPubTypes() {
2150   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2151          E = CUMap.end(); I != E; ++I) {
2152     CompileUnit *TheCU = I->second;
2153     // Start the dwarf pubtypes section.
2154     Asm->OutStreamer.SwitchSection(
2155       Asm->getObjFileLowering().getDwarfPubTypesSection());
2156     Asm->OutStreamer.AddComment("Length of Public Types Info");
2157     Asm->EmitLabelDifference(
2158       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2159       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2160
2161     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2162                                                   TheCU->getUniqueID()));
2163
2164     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2165     Asm->EmitInt16(dwarf::DWARF_VERSION);
2166
2167     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2168     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2169     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2170                                               TheCU->getUniqueID()),
2171                            DwarfInfoSectionSym);
2172
2173     Asm->OutStreamer.AddComment("Compilation Unit Length");
2174     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2175                                                 TheCU->getUniqueID()),
2176                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2177                                                 TheCU->getUniqueID()),
2178                              4);
2179
2180     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2181     for (StringMap<DIE*>::const_iterator
2182            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2183       const char *Name = GI->getKeyData();
2184       DIE *Entity = GI->second;
2185
2186       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2187       Asm->EmitInt32(Entity->getOffset());
2188
2189       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2190       // Emit the name with a terminating null byte.
2191       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2192     }
2193
2194     Asm->OutStreamer.AddComment("End Mark");
2195     Asm->EmitInt32(0);
2196     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2197                                                   TheCU->getUniqueID()));
2198   }
2199 }
2200
2201 // Emit strings into a string section.
2202 void DwarfUnits::emitStrings(const MCSection *StrSection,
2203                              const MCSection *OffsetSection = NULL,
2204                              const MCSymbol *StrSecSym = NULL) {
2205
2206   if (StringPool.empty()) return;
2207
2208   // Start the dwarf str section.
2209   Asm->OutStreamer.SwitchSection(StrSection);
2210
2211   // Get all of the string pool entries and put them in an array by their ID so
2212   // we can sort them.
2213   SmallVector<std::pair<unsigned,
2214                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2215
2216   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2217          I = StringPool.begin(), E = StringPool.end();
2218        I != E; ++I)
2219     Entries.push_back(std::make_pair(I->second.second, &*I));
2220
2221   array_pod_sort(Entries.begin(), Entries.end());
2222
2223   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2224     // Emit a label for reference from debug information entries.
2225     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2226
2227     // Emit the string itself with a terminating null byte.
2228     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2229                                          Entries[i].second->getKeyLength()+1));
2230   }
2231
2232   // If we've got an offset section go ahead and emit that now as well.
2233   if (OffsetSection) {
2234     Asm->OutStreamer.SwitchSection(OffsetSection);
2235     unsigned offset = 0;
2236     unsigned size = 4; // FIXME: DWARF64 is 8.
2237     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2238       Asm->OutStreamer.EmitIntValue(offset, size);
2239       offset += Entries[i].second->getKeyLength() + 1;
2240     }
2241   }
2242 }
2243
2244 // Emit strings into a string section.
2245 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2246
2247   if (AddressPool.empty()) return;
2248
2249   // Start the dwarf addr section.
2250   Asm->OutStreamer.SwitchSection(AddrSection);
2251
2252   // Get all of the string pool entries and put them in an array by their ID so
2253   // we can sort them.
2254   SmallVector<std::pair<unsigned,
2255                         std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2256
2257   for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2258          I = AddressPool.begin(), E = AddressPool.end();
2259        I != E; ++I)
2260     Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2261
2262   array_pod_sort(Entries.begin(), Entries.end());
2263
2264   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2265     // Emit a label for reference from debug information entries.
2266     MCSymbol *Sym = Entries[i].second->first;
2267     if (Sym)
2268       Asm->EmitLabelReference(Entries[i].second->first,
2269                               Asm->getDataLayout().getPointerSize());
2270     else
2271       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2272   }
2273
2274 }
2275
2276 // Emit visible names into a debug str section.
2277 void DwarfDebug::emitDebugStr() {
2278   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2279   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2280 }
2281
2282 // Emit visible names into a debug loc section.
2283 void DwarfDebug::emitDebugLoc() {
2284   if (DotDebugLocEntries.empty())
2285     return;
2286
2287   for (SmallVector<DotDebugLocEntry, 4>::iterator
2288          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2289        I != E; ++I) {
2290     DotDebugLocEntry &Entry = *I;
2291     if (I + 1 != DotDebugLocEntries.end())
2292       Entry.Merge(I+1);
2293   }
2294
2295   // Start the dwarf loc section.
2296   Asm->OutStreamer.SwitchSection(
2297     Asm->getObjFileLowering().getDwarfLocSection());
2298   unsigned char Size = Asm->getDataLayout().getPointerSize();
2299   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2300   unsigned index = 1;
2301   for (SmallVector<DotDebugLocEntry, 4>::iterator
2302          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2303        I != E; ++I, ++index) {
2304     DotDebugLocEntry &Entry = *I;
2305     if (Entry.isMerged()) continue;
2306     if (Entry.isEmpty()) {
2307       Asm->OutStreamer.EmitIntValue(0, Size);
2308       Asm->OutStreamer.EmitIntValue(0, Size);
2309       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2310     } else {
2311       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2312       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2313       DIVariable DV(Entry.Variable);
2314       Asm->OutStreamer.AddComment("Loc expr size");
2315       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2316       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2317       Asm->EmitLabelDifference(end, begin, 2);
2318       Asm->OutStreamer.EmitLabel(begin);
2319       if (Entry.isInt()) {
2320         DIBasicType BTy(DV.getType());
2321         if (BTy.Verify() &&
2322             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2323              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2324           Asm->OutStreamer.AddComment("DW_OP_consts");
2325           Asm->EmitInt8(dwarf::DW_OP_consts);
2326           Asm->EmitSLEB128(Entry.getInt());
2327         } else {
2328           Asm->OutStreamer.AddComment("DW_OP_constu");
2329           Asm->EmitInt8(dwarf::DW_OP_constu);
2330           Asm->EmitULEB128(Entry.getInt());
2331         }
2332       } else if (Entry.isLocation()) {
2333         if (!DV.hasComplexAddress())
2334           // Regular entry.
2335           Asm->EmitDwarfRegOp(Entry.Loc);
2336         else {
2337           // Complex address entry.
2338           unsigned N = DV.getNumAddrElements();
2339           unsigned i = 0;
2340           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2341             if (Entry.Loc.getOffset()) {
2342               i = 2;
2343               Asm->EmitDwarfRegOp(Entry.Loc);
2344               Asm->OutStreamer.AddComment("DW_OP_deref");
2345               Asm->EmitInt8(dwarf::DW_OP_deref);
2346               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2347               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2348               Asm->EmitSLEB128(DV.getAddrElement(1));
2349             } else {
2350               // If first address element is OpPlus then emit
2351               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2352               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2353               Asm->EmitDwarfRegOp(Loc);
2354               i = 2;
2355             }
2356           } else {
2357             Asm->EmitDwarfRegOp(Entry.Loc);
2358           }
2359
2360           // Emit remaining complex address elements.
2361           for (; i < N; ++i) {
2362             uint64_t Element = DV.getAddrElement(i);
2363             if (Element == DIBuilder::OpPlus) {
2364               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2365               Asm->EmitULEB128(DV.getAddrElement(++i));
2366             } else if (Element == DIBuilder::OpDeref) {
2367               if (!Entry.Loc.isReg())
2368                 Asm->EmitInt8(dwarf::DW_OP_deref);
2369             } else
2370               llvm_unreachable("unknown Opcode found in complex address");
2371           }
2372         }
2373       }
2374       // else ... ignore constant fp. There is not any good way to
2375       // to represent them here in dwarf.
2376       Asm->OutStreamer.EmitLabel(end);
2377     }
2378   }
2379 }
2380
2381 // Emit visible names into a debug aranges section.
2382 void DwarfDebug::emitDebugARanges() {
2383   // Start the dwarf aranges section.
2384   Asm->OutStreamer.SwitchSection(
2385                           Asm->getObjFileLowering().getDwarfARangesSection());
2386 }
2387
2388 // Emit visible names into a debug ranges section.
2389 void DwarfDebug::emitDebugRanges() {
2390   // Start the dwarf ranges section.
2391   Asm->OutStreamer.SwitchSection(
2392     Asm->getObjFileLowering().getDwarfRangesSection());
2393   unsigned char Size = Asm->getDataLayout().getPointerSize();
2394   for (SmallVector<const MCSymbol *, 8>::iterator
2395          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2396        I != E; ++I) {
2397     if (*I)
2398       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2399     else
2400       Asm->OutStreamer.EmitIntValue(0, Size);
2401   }
2402 }
2403
2404 // Emit visible names into a debug macinfo section.
2405 void DwarfDebug::emitDebugMacInfo() {
2406   if (const MCSection *LineInfo =
2407       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2408     // Start the dwarf macinfo section.
2409     Asm->OutStreamer.SwitchSection(LineInfo);
2410   }
2411 }
2412
2413 // Emit inline info using following format.
2414 // Section Header:
2415 // 1. length of section
2416 // 2. Dwarf version number
2417 // 3. address size.
2418 //
2419 // Entries (one "entry" for each function that was inlined):
2420 //
2421 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2422 //   otherwise offset into __debug_str for regular function name.
2423 // 2. offset into __debug_str section for regular function name.
2424 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2425 // instances for the function.
2426 //
2427 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2428 // inlined instance; the die_offset points to the inlined_subroutine die in the
2429 // __debug_info section, and the low_pc is the starting address for the
2430 // inlining instance.
2431 void DwarfDebug::emitDebugInlineInfo() {
2432   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2433     return;
2434
2435   if (!FirstCU)
2436     return;
2437
2438   Asm->OutStreamer.SwitchSection(
2439                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2440
2441   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2442   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2443                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2444
2445   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2446
2447   Asm->OutStreamer.AddComment("Dwarf Version");
2448   Asm->EmitInt16(dwarf::DWARF_VERSION);
2449   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2450   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2451
2452   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2453          E = InlinedSPNodes.end(); I != E; ++I) {
2454
2455     const MDNode *Node = *I;
2456     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2457       = InlineInfo.find(Node);
2458     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2459     DISubprogram SP(Node);
2460     StringRef LName = SP.getLinkageName();
2461     StringRef Name = SP.getName();
2462
2463     Asm->OutStreamer.AddComment("MIPS linkage name");
2464     if (LName.empty())
2465       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2466                              DwarfStrSectionSym);
2467     else
2468       Asm->EmitSectionOffset(InfoHolder
2469                              .getStringPoolEntry(getRealLinkageName(LName)),
2470                              DwarfStrSectionSym);
2471
2472     Asm->OutStreamer.AddComment("Function name");
2473     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2474                            DwarfStrSectionSym);
2475     Asm->EmitULEB128(Labels.size(), "Inline count");
2476
2477     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2478            LE = Labels.end(); LI != LE; ++LI) {
2479       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2480       Asm->EmitInt32(LI->second->getOffset());
2481
2482       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2483       Asm->OutStreamer.EmitSymbolValue(LI->first,
2484                                        Asm->getDataLayout().getPointerSize());
2485     }
2486   }
2487
2488   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2489 }
2490
2491 // DWARF5 Experimental Separate Dwarf emitters.
2492
2493 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2494 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2495 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2496 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2497 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2498   DICompileUnit DIUnit(N);
2499   CompilationDir = DIUnit.getDirectory();
2500
2501   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2502   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2503                                        DIUnit.getLanguage(), Die, Asm,
2504                                        this, &SkeletonHolder);
2505
2506   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2507                         DIUnit.getSplitDebugFilename());
2508
2509   // This should be a unique identifier when we want to build .dwp files.
2510   NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2511
2512   // FIXME: The addr base should be relative for each compile unit, however,
2513   // this one is going to be 0 anyhow.
2514   NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0);
2515
2516   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2517   // into an entity. We're using 0, or a NULL label for this.
2518   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2519
2520   // DW_AT_stmt_list is a offset of line number information for this
2521   // compile unit in debug_line section.
2522   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2523     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2524                     DwarfLineSectionSym);
2525   else
2526     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2527
2528   if (!CompilationDir.empty())
2529     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2530
2531   SkeletonHolder.addUnit(NewCU);
2532   SkeletonCUs.push_back(NewCU);
2533
2534   return NewCU;
2535 }
2536
2537 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2538   assert(useSplitDwarf() && "No split dwarf debug info?");
2539   emitAbbrevs(Section, &SkeletonAbbrevs);
2540 }
2541
2542 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2543 // compile units that would normally be in debug_info.
2544 void DwarfDebug::emitDebugInfoDWO() {
2545   assert(useSplitDwarf() && "No split dwarf debug info?");
2546   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2547                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2548                        DwarfAbbrevDWOSectionSym);
2549 }
2550
2551 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2552 // abbreviations for the .debug_info.dwo section.
2553 void DwarfDebug::emitDebugAbbrevDWO() {
2554   assert(useSplitDwarf() && "No split dwarf?");
2555   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2556               &Abbreviations);
2557 }
2558
2559 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2560 // string section and is identical in format to traditional .debug_str
2561 // sections.
2562 void DwarfDebug::emitDebugStrDWO() {
2563   assert(useSplitDwarf() && "No split dwarf?");
2564   const MCSection *OffSec = Asm->getObjFileLowering()
2565                             .getDwarfStrOffDWOSection();
2566   const MCSymbol *StrSym = DwarfStrSectionSym;
2567   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2568                          OffSec, StrSym);
2569 }