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