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   // Emit all the DIEs into a debug info section
 907   if (!useDwarfFission()) {
 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
 932     // Emit info into a debug str section.
 933     emitDebugStr();
 934   }
 935
 936   // Emit info into the dwarf accelerator table sections.
 937   if (useDwarfAccelTables()) {
 938     emitAccelNames();
 939     emitAccelObjC();
 940     emitAccelNamespaces();
 941     emitAccelTypes();
 942   }
 943
 944   // Emit info into a debug pubtypes section.
 945   // TODO: When we don't need the option anymore we can
 946   // remove all of the code that adds to the table.
 947   if (useDarwinGDBCompat())
 948     emitDebugPubTypes();
 949
 950   // clean up.
 951   SPMap.clear();
 952   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
 953          E = CUMap.end(); I != E; ++I)
 954     delete I->second;
 955   FirstCU = NULL;  // Reset for the next Module, if any.
 956 }
 957
 958 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
 959 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
 960                                               DebugLoc ScopeLoc) {
 961   LLVMContext &Ctx = DV->getContext();
 962   // More then one inlined variable corresponds to one abstract variable.
 963   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
 964   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
 965   if (AbsDbgVariable)
 966     return AbsDbgVariable;
 967
 968   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
 969   if (!Scope)
 970     return NULL;
 971
 972   AbsDbgVariable = new DbgVariable(Var, NULL);
 973   addScopeVariable(Scope, AbsDbgVariable);
 974   AbstractVariables[Var] = AbsDbgVariable;
 975   return AbsDbgVariable;
 976 }
 977
 978 /// addCurrentFnArgument - If Var is a current function argument then add
 979 /// it to CurrentFnArguments list.
 980 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
 981                                       DbgVariable *Var, LexicalScope *Scope) {
 982   if (!LScopes.isCurrentFunctionScope(Scope))
 983     return false;
 984   DIVariable DV = Var->getVariable();
 985   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
 986     return false;
 987   unsigned ArgNo = DV.getArgNumber();
 988   if (ArgNo == 0)
 989     return false;
 990
 991   size_t Size = CurrentFnArguments.size();
 992   if (Size == 0)
 993     CurrentFnArguments.resize(MF->getFunction()->arg_size());
 994   // llvm::Function argument size is not good indicator of how many
 995   // arguments does the function have at source level.
 996   if (ArgNo > Size)
 997     CurrentFnArguments.resize(ArgNo * 2);
 998   CurrentFnArguments[ArgNo - 1] = Var;
 999   return true;
1000 }
1001
1002 /// collectVariableInfoFromMMITable - Collect variable information from
1003 /// side table maintained by MMI.
1004 void
1005 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1006                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1007   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1008   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1009          VE = VMap.end(); VI != VE; ++VI) {
1010     const MDNode *Var = VI->first;
1011     if (!Var) continue;
1012     Processed.insert(Var);
1013     DIVariable DV(Var);
1014     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1015
1016     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1017
1018     // If variable scope is not found then skip this variable.
1019     if (Scope == 0)
1020       continue;
1021
1022     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1023     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1024     RegVar->setFrameIndex(VP.first);
1025     if (!addCurrentFnArgument(MF, RegVar, Scope))
1026       addScopeVariable(Scope, RegVar);
1027     if (AbsDbgVariable)
1028       AbsDbgVariable->setFrameIndex(VP.first);
1029   }
1030 }
1031
1032 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
1033 /// DBG_VALUE instruction, is in a defined reg.
1034 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1035   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1036   return MI->getNumOperands() == 3 &&
1037          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1038          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1039 }
1040
1041 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
1042 /// at MI.
1043 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1044                                          const MCSymbol *FLabel,
1045                                          const MCSymbol *SLabel,
1046                                          const MachineInstr *MI) {
1047   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1048
1049   if (MI->getNumOperands() != 3) {
1050     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1051     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1052   }
1053   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1054     MachineLocation MLoc;
1055     MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1056     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1057   }
1058   if (MI->getOperand(0).isImm())
1059     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1060   if (MI->getOperand(0).isFPImm())
1061     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1062   if (MI->getOperand(0).isCImm())
1063     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1064
1065   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1066 }
1067
1068 /// collectVariableInfo - Find variables for each lexical scope.
1069 void
1070 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1071                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1072
1073   /// collection info from MMI table.
1074   collectVariableInfoFromMMITable(MF, Processed);
1075
1076   for (SmallVectorImpl<const MDNode*>::const_iterator
1077          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1078          ++UVI) {
1079     const MDNode *Var = *UVI;
1080     if (Processed.count(Var))
1081       continue;
1082
1083     // History contains relevant DBG_VALUE instructions for Var and instructions
1084     // clobbering it.
1085     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1086     if (History.empty())
1087       continue;
1088     const MachineInstr *MInsn = History.front();
1089
1090     DIVariable DV(Var);
1091     LexicalScope *Scope = NULL;
1092     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1093         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1094       Scope = LScopes.getCurrentFunctionScope();
1095     else {
1096       if (DV.getVersion() <= LLVMDebugVersion9)
1097         Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
1098       else {
1099         if (MDNode *IA = DV.getInlinedAt())
1100           Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1101         else
1102           Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1103       }
1104     }
1105     // If variable scope is not found then skip this variable.
1106     if (!Scope)
1107       continue;
1108
1109     Processed.insert(DV);
1110     assert(MInsn->isDebugValue() && "History must begin with debug value");
1111     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1112     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1113     if (!addCurrentFnArgument(MF, RegVar, Scope))
1114       addScopeVariable(Scope, RegVar);
1115     if (AbsVar)
1116       AbsVar->setMInsn(MInsn);
1117
1118     // Simplify ranges that are fully coalesced.
1119     if (History.size() <= 1 || (History.size() == 2 &&
1120                                 MInsn->isIdenticalTo(History.back()))) {
1121       RegVar->setMInsn(MInsn);
1122       continue;
1123     }
1124
1125     // handle multiple DBG_VALUE instructions describing one variable.
1126     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1127
1128     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1129            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1130       const MachineInstr *Begin = *HI;
1131       assert(Begin->isDebugValue() && "Invalid History entry");
1132
1133       // Check if DBG_VALUE is truncating a range.
1134       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1135           && !Begin->getOperand(0).getReg())
1136         continue;
1137
1138       // Compute the range for a register location.
1139       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1140       const MCSymbol *SLabel = 0;
1141
1142       if (HI + 1 == HE)
1143         // If Begin is the last instruction in History then its value is valid
1144         // until the end of the function.
1145         SLabel = FunctionEndSym;
1146       else {
1147         const MachineInstr *End = HI[1];
1148         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1149               << "\t" << *Begin << "\t" << *End << "\n");
1150         if (End->isDebugValue())
1151           SLabel = getLabelBeforeInsn(End);
1152         else {
1153           // End is a normal instruction clobbering the range.
1154           SLabel = getLabelAfterInsn(End);
1155           assert(SLabel && "Forgot label after clobber instruction");
1156           ++HI;
1157         }
1158       }
1159
1160       // The value is valid until the next DBG_VALUE or clobber.
1161       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1162                                                     Begin));
1163     }
1164     DotDebugLocEntries.push_back(DotDebugLocEntry());
1165   }
1166
1167   // Collect info for variables that were optimized out.
1168   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1169   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1170   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1171     DIVariable DV(Variables.getElement(i));
1172     if (!DV || !DV.Verify() || !Processed.insert(DV))
1173       continue;
1174     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1175       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1176   }
1177 }
1178
1179 /// getLabelBeforeInsn - Return Label preceding the instruction.
1180 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1181   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1182   assert(Label && "Didn't insert label before instruction");
1183   return Label;
1184 }
1185
1186 /// getLabelAfterInsn - Return Label immediately following the instruction.
1187 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1188   return LabelsAfterInsn.lookup(MI);
1189 }
1190
1191 /// beginInstruction - Process beginning of an instruction.
1192 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1193   // Check if source location changes, but ignore DBG_VALUE locations.
1194   if (!MI->isDebugValue()) {
1195     DebugLoc DL = MI->getDebugLoc();
1196     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1197       unsigned Flags = 0;
1198       PrevInstLoc = DL;
1199       if (DL == PrologEndLoc) {
1200         Flags |= DWARF2_FLAG_PROLOGUE_END;
1201         PrologEndLoc = DebugLoc();
1202       }
1203       if (PrologEndLoc.isUnknown())
1204         Flags |= DWARF2_FLAG_IS_STMT;
1205
1206       if (!DL.isUnknown()) {
1207         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1208         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1209       } else
1210         recordSourceLine(0, 0, 0, 0);
1211     }
1212   }
1213
1214   // Insert labels where requested.
1215   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1216     LabelsBeforeInsn.find(MI);
1217
1218   // No label needed.
1219   if (I == LabelsBeforeInsn.end())
1220     return;
1221
1222   // Label already assigned.
1223   if (I->second)
1224     return;
1225
1226   if (!PrevLabel) {
1227     PrevLabel = MMI->getContext().CreateTempSymbol();
1228     Asm->OutStreamer.EmitLabel(PrevLabel);
1229   }
1230   I->second = PrevLabel;
1231 }
1232
1233 /// endInstruction - Process end of an instruction.
1234 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1235   // Don't create a new label after DBG_VALUE instructions.
1236   // They don't generate code.
1237   if (!MI->isDebugValue())
1238     PrevLabel = 0;
1239
1240   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1241     LabelsAfterInsn.find(MI);
1242
1243   // No label needed.
1244   if (I == LabelsAfterInsn.end())
1245     return;
1246
1247   // Label already assigned.
1248   if (I->second)
1249     return;
1250
1251   // We need a label after this instruction.
1252   if (!PrevLabel) {
1253     PrevLabel = MMI->getContext().CreateTempSymbol();
1254     Asm->OutStreamer.EmitLabel(PrevLabel);
1255   }
1256   I->second = PrevLabel;
1257 }
1258
1259 /// identifyScopeMarkers() -
1260 /// Each LexicalScope has first instruction and last instruction to mark
1261 /// beginning and end of a scope respectively. Create an inverse map that list
1262 /// scopes starts (and ends) with an instruction. One instruction may start (or
1263 /// end) multiple scopes. Ignore scopes that are not reachable.
1264 void DwarfDebug::identifyScopeMarkers() {
1265   SmallVector<LexicalScope *, 4> WorkList;
1266   WorkList.push_back(LScopes.getCurrentFunctionScope());
1267   while (!WorkList.empty()) {
1268     LexicalScope *S = WorkList.pop_back_val();
1269
1270     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1271     if (!Children.empty())
1272       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1273              SE = Children.end(); SI != SE; ++SI)
1274         WorkList.push_back(*SI);
1275
1276     if (S->isAbstractScope())
1277       continue;
1278
1279     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1280     if (Ranges.empty())
1281       continue;
1282     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1283            RE = Ranges.end(); RI != RE; ++RI) {
1284       assert(RI->first && "InsnRange does not have first instruction!");
1285       assert(RI->second && "InsnRange does not have second instruction!");
1286       requestLabelBeforeInsn(RI->first);
1287       requestLabelAfterInsn(RI->second);
1288     }
1289   }
1290 }
1291
1292 /// getScopeNode - Get MDNode for DebugLoc's scope.
1293 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1294   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1295     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1296   return DL.getScope(Ctx);
1297 }
1298
1299 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1300 /// line number info for the function.
1301 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1302   const MDNode *Scope = getScopeNode(DL, Ctx);
1303   DISubprogram SP = getDISubprogram(Scope);
1304   if (SP.Verify()) {
1305     // Check for number of operands since the compatibility is
1306     // cheap here.
1307     if (SP->getNumOperands() > 19)
1308       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1309     else
1310       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1311   }
1312
1313   return DebugLoc();
1314 }
1315
1316 /// beginFunction - Gather pre-function debug information.  Assumes being
1317 /// emitted immediately after the function entry point.
1318 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1319   if (!MMI->hasDebugInfo()) return;
1320   LScopes.initialize(*MF);
1321   if (LScopes.empty()) return;
1322   identifyScopeMarkers();
1323
1324   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1325                                         Asm->getFunctionNumber());
1326   // Assumes in correct section after the entry point.
1327   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1328
1329   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1330
1331   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1332   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1333   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1334
1335   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1336        I != E; ++I) {
1337     bool AtBlockEntry = true;
1338     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1339          II != IE; ++II) {
1340       const MachineInstr *MI = II;
1341
1342       if (MI->isDebugValue()) {
1343         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1344
1345         // Keep track of user variables.
1346         const MDNode *Var =
1347           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1348
1349         // Variable is in a register, we need to check for clobbers.
1350         if (isDbgValueInDefinedReg(MI))
1351           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1352
1353         // Check the history of this variable.
1354         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1355         if (History.empty()) {
1356           UserVariables.push_back(Var);
1357           // The first mention of a function argument gets the FunctionBeginSym
1358           // label, so arguments are visible when breaking at function entry.
1359           DIVariable DV(Var);
1360           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1361               DISubprogram(getDISubprogram(DV.getContext()))
1362                 .describes(MF->getFunction()))
1363             LabelsBeforeInsn[MI] = FunctionBeginSym;
1364         } else {
1365           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1366           const MachineInstr *Prev = History.back();
1367           if (Prev->isDebugValue()) {
1368             // Coalesce identical entries at the end of History.
1369             if (History.size() >= 2 &&
1370                 Prev->isIdenticalTo(History[History.size() - 2])) {
1371               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1372                     << "\t" << *Prev
1373                     << "\t" << *History[History.size() - 2] << "\n");
1374               History.pop_back();
1375             }
1376
1377             // Terminate old register assignments that don't reach MI;
1378             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1379             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1380                 isDbgValueInDefinedReg(Prev)) {
1381               // Previous register assignment needs to terminate at the end of
1382               // its basic block.
1383               MachineBasicBlock::const_iterator LastMI =
1384                 PrevMBB->getLastNonDebugInstr();
1385               if (LastMI == PrevMBB->end()) {
1386                 // Drop DBG_VALUE for empty range.
1387                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1388                       << "\t" << *Prev << "\n");
1389                 History.pop_back();
1390               }
1391               else {
1392                 // Terminate after LastMI.
1393                 History.push_back(LastMI);
1394               }
1395             }
1396           }
1397         }
1398         History.push_back(MI);
1399       } else {
1400         // Not a DBG_VALUE instruction.
1401         if (!MI->isLabel())
1402           AtBlockEntry = false;
1403
1404         // First known non-DBG_VALUE and non-frame setup location marks
1405         // the beginning of the function body.
1406         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1407             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1408           PrologEndLoc = MI->getDebugLoc();
1409
1410         // Check if the instruction clobbers any registers with debug vars.
1411         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1412                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1413           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1414             continue;
1415           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1416                AI.isValid(); ++AI) {
1417             unsigned Reg = *AI;
1418             const MDNode *Var = LiveUserVar[Reg];
1419             if (!Var)
1420               continue;
1421             // Reg is now clobbered.
1422             LiveUserVar[Reg] = 0;
1423
1424             // Was MD last defined by a DBG_VALUE referring to Reg?
1425             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1426             if (HistI == DbgValues.end())
1427               continue;
1428             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1429             if (History.empty())
1430               continue;
1431             const MachineInstr *Prev = History.back();
1432             // Sanity-check: Register assignments are terminated at the end of
1433             // their block.
1434             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1435               continue;
1436             // Is the variable still in Reg?
1437             if (!isDbgValueInDefinedReg(Prev) ||
1438                 Prev->getOperand(0).getReg() != Reg)
1439               continue;
1440             // Var is clobbered. Make sure the next instruction gets a label.
1441             History.push_back(MI);
1442           }
1443         }
1444       }
1445     }
1446   }
1447
1448   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1449        I != E; ++I) {
1450     SmallVectorImpl<const MachineInstr*> &History = I->second;
1451     if (History.empty())
1452       continue;
1453
1454     // Make sure the final register assignments are terminated.
1455     const MachineInstr *Prev = History.back();
1456     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1457       const MachineBasicBlock *PrevMBB = Prev->getParent();
1458       MachineBasicBlock::const_iterator LastMI =
1459         PrevMBB->getLastNonDebugInstr();
1460       if (LastMI == PrevMBB->end())
1461         // Drop DBG_VALUE for empty range.
1462         History.pop_back();
1463       else {
1464         // Terminate after LastMI.
1465         History.push_back(LastMI);
1466       }
1467     }
1468     // Request labels for the full history.
1469     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1470       const MachineInstr *MI = History[i];
1471       if (MI->isDebugValue())
1472         requestLabelBeforeInsn(MI);
1473       else
1474         requestLabelAfterInsn(MI);
1475     }
1476   }
1477
1478   PrevInstLoc = DebugLoc();
1479   PrevLabel = FunctionBeginSym;
1480
1481   // Record beginning of function.
1482   if (!PrologEndLoc.isUnknown()) {
1483     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1484                                        MF->getFunction()->getContext());
1485     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1486                      FnStartDL.getScope(MF->getFunction()->getContext()),
1487                      0);
1488   }
1489 }
1490
1491 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1492 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1493   ScopeVariables[LS].push_back(Var);
1494 //  Vars.push_back(Var);
1495 }
1496
1497 /// endFunction - Gather and emit post-function debug information.
1498 ///
1499 void DwarfDebug::endFunction(const MachineFunction *MF) {
1500   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1501
1502   // Define end label for subprogram.
1503   FunctionEndSym = Asm->GetTempSymbol("func_end",
1504                                       Asm->getFunctionNumber());
1505   // Assumes in correct section after the entry point.
1506   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1507
1508   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1509   collectVariableInfo(MF, ProcessedVars);
1510
1511   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1512   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1513   assert(TheCU && "Unable to find compile unit!");
1514
1515   // Construct abstract scopes.
1516   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1517   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1518     LexicalScope *AScope = AList[i];
1519     DISubprogram SP(AScope->getScopeNode());
1520     if (SP.Verify()) {
1521       // Collect info for variables that were optimized out.
1522       DIArray Variables = SP.getVariables();
1523       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1524         DIVariable DV(Variables.getElement(i));
1525         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1526           continue;
1527         // Check that DbgVariable for DV wasn't created earlier, when
1528         // findAbstractVariable() was called for inlined instance of DV.
1529         LLVMContext &Ctx = DV->getContext();
1530         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1531         if (AbstractVariables.lookup(CleanDV))
1532           continue;
1533         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1534           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1535       }
1536     }
1537     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1538       constructScopeDIE(TheCU, AScope);
1539   }
1540
1541   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1542
1543   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1544     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1545
1546   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1547                                                MMI->getFrameMoves()));
1548
1549   // Clear debug info
1550   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1551          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1552     DeleteContainerPointers(I->second);
1553   ScopeVariables.clear();
1554   DeleteContainerPointers(CurrentFnArguments);
1555   UserVariables.clear();
1556   DbgValues.clear();
1557   AbstractVariables.clear();
1558   LabelsBeforeInsn.clear();
1559   LabelsAfterInsn.clear();
1560   PrevLabel = NULL;
1561 }
1562
1563 /// recordSourceLine - Register a source line with debug info. Returns the
1564 /// unique label that was emitted and which provides correspondence to
1565 /// the source line list.
1566 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1567                                   unsigned Flags) {
1568   StringRef Fn;
1569   StringRef Dir;
1570   unsigned Src = 1;
1571   if (S) {
1572     DIDescriptor Scope(S);
1573
1574     if (Scope.isCompileUnit()) {
1575       DICompileUnit CU(S);
1576       Fn = CU.getFilename();
1577       Dir = CU.getDirectory();
1578     } else if (Scope.isFile()) {
1579       DIFile F(S);
1580       Fn = F.getFilename();
1581       Dir = F.getDirectory();
1582     } else if (Scope.isSubprogram()) {
1583       DISubprogram SP(S);
1584       Fn = SP.getFilename();
1585       Dir = SP.getDirectory();
1586     } else if (Scope.isLexicalBlockFile()) {
1587       DILexicalBlockFile DBF(S);
1588       Fn = DBF.getFilename();
1589       Dir = DBF.getDirectory();
1590     } else if (Scope.isLexicalBlock()) {
1591       DILexicalBlock DB(S);
1592       Fn = DB.getFilename();
1593       Dir = DB.getDirectory();
1594     } else
1595       llvm_unreachable("Unexpected scope info");
1596
1597     Src = getOrCreateSourceID(Fn, Dir);
1598   }
1599   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1600 }
1601
1602 //===----------------------------------------------------------------------===//
1603 // Emit Methods
1604 //===----------------------------------------------------------------------===//
1605
1606 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1607 ///
1608 unsigned
1609 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1610   // Get the children.
1611   const std::vector<DIE *> &Children = Die->getChildren();
1612
1613   // Record the abbreviation.
1614   assignAbbrevNumber(Die->getAbbrev());
1615
1616   // Get the abbreviation for this DIE.
1617   unsigned AbbrevNumber = Die->getAbbrevNumber();
1618   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1619
1620   // Set DIE offset
1621   Die->setOffset(Offset);
1622
1623   // Start the size with the size of abbreviation code.
1624   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1625
1626   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1627   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1628
1629   // Size the DIE attribute values.
1630   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1631     // Size attribute value.
1632     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1633
1634   // Size the DIE children if any.
1635   if (!Children.empty()) {
1636     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1637            "Children flag not set");
1638
1639     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1640       Offset = computeSizeAndOffset(Children[j], Offset);
1641
1642     // End of children marker.
1643     Offset += sizeof(int8_t);
1644   }
1645
1646   Die->setSize(Offset - Die->getOffset());
1647   return Offset;
1648 }
1649
1650 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1651 ///
1652 void DwarfDebug::computeSizeAndOffsets() {
1653   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1654          E = CUMap.end(); I != E; ++I) {
1655     // Compute size of compile unit header.
1656     unsigned Offset =
1657       sizeof(int32_t) + // Length of Compilation Unit Info
1658       sizeof(int16_t) + // DWARF version number
1659       sizeof(int32_t) + // Offset Into Abbrev. Section
1660       sizeof(int8_t);   // Pointer Size (in bytes)
1661     computeSizeAndOffset(I->second->getCUDie(), Offset);
1662   }
1663 }
1664
1665 /// emitSectionLabels - Emit initial Dwarf sections with a label at
1666 /// the start of each one.
1667 void DwarfDebug::emitSectionLabels() {
1668   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1669
1670   // Dwarf sections base addresses.
1671   DwarfInfoSectionSym =
1672     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1673   DwarfAbbrevSectionSym =
1674     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1675   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1676
1677   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1678     emitSectionSym(Asm, MacroInfo);
1679
1680   emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1681   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1682   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1683   DwarfStrSectionSym =
1684     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1685   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1686                                              "debug_range");
1687
1688   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1689                                            "section_debug_loc");
1690
1691   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1692   emitSectionSym(Asm, TLOF.getDataSection());
1693 }
1694
1695 /// emitDIE - Recursively emits a debug information entry.
1696 ///
1697 void DwarfDebug::emitDIE(DIE *Die) {
1698   // Get the abbreviation for this DIE.
1699   unsigned AbbrevNumber = Die->getAbbrevNumber();
1700   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1701
1702   // Emit the code (index) for the abbreviation.
1703   if (Asm->isVerbose())
1704     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1705                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1706                                 Twine::utohexstr(Die->getSize()) + " " +
1707                                 dwarf::TagString(Abbrev->getTag()));
1708   Asm->EmitULEB128(AbbrevNumber);
1709
1710   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1711   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1712
1713   // Emit the DIE attribute values.
1714   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1715     unsigned Attr = AbbrevData[i].getAttribute();
1716     unsigned Form = AbbrevData[i].getForm();
1717     assert(Form && "Too many attributes for DIE (check abbreviation)");
1718
1719     if (Asm->isVerbose())
1720       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1721
1722     switch (Attr) {
1723     case dwarf::DW_AT_abstract_origin: {
1724       DIEEntry *E = cast<DIEEntry>(Values[i]);
1725       DIE *Origin = E->getEntry();
1726       unsigned Addr = Origin->getOffset();
1727       Asm->EmitInt32(Addr);
1728       break;
1729     }
1730     case dwarf::DW_AT_ranges: {
1731       // DW_AT_range Value encodes offset in debug_range section.
1732       DIEInteger *V = cast<DIEInteger>(Values[i]);
1733
1734       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1735         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1736                                  V->getValue(),
1737                                  4);
1738       } else {
1739         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1740                                        V->getValue(),
1741                                        DwarfDebugRangeSectionSym,
1742                                        4);
1743       }
1744       break;
1745     }
1746     case dwarf::DW_AT_location: {
1747       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1748         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1749           Asm->EmitLabelReference(L->getValue(), 4);
1750         else
1751           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1752       } else {
1753         Values[i]->EmitValue(Asm, Form);
1754       }
1755       break;
1756     }
1757     case dwarf::DW_AT_accessibility: {
1758       if (Asm->isVerbose()) {
1759         DIEInteger *V = cast<DIEInteger>(Values[i]);
1760         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1761       }
1762       Values[i]->EmitValue(Asm, Form);
1763       break;
1764     }
1765     default:
1766       // Emit an attribute using the defined form.
1767       Values[i]->EmitValue(Asm, Form);
1768       break;
1769     }
1770   }
1771
1772   // Emit the DIE children if any.
1773   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1774     const std::vector<DIE *> &Children = Die->getChildren();
1775
1776     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1777       emitDIE(Children[j]);
1778
1779     if (Asm->isVerbose())
1780       Asm->OutStreamer.AddComment("End Of Children Mark");
1781     Asm->EmitInt8(0);
1782   }
1783 }
1784
1785 /// emitDebugInfo - Emit the debug info section.
1786 ///
1787 void DwarfDebug::emitDebugInfo() {
1788   // Start debug info section.
1789   Asm->OutStreamer.SwitchSection(
1790                             Asm->getObjFileLowering().getDwarfInfoSection());
1791   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1792          E = CUMap.end(); I != E; ++I) {
1793     CompileUnit *TheCU = I->second;
1794     DIE *Die = TheCU->getCUDie();
1795
1796     // Emit the compile units header.
1797     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1798                                                   TheCU->getID()));
1799
1800     // Emit size of content not including length itself
1801     unsigned ContentSize = Die->getSize() +
1802       sizeof(int16_t) + // DWARF version number
1803       sizeof(int32_t) + // Offset Into Abbrev. Section
1804       sizeof(int8_t);   // Pointer Size (in bytes)
1805
1806     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1807     Asm->EmitInt32(ContentSize);
1808     Asm->OutStreamer.AddComment("DWARF version number");
1809     Asm->EmitInt16(dwarf::DWARF_VERSION);
1810     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1811     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1812                            DwarfAbbrevSectionSym);
1813     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1814     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1815
1816     emitDIE(Die);
1817     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1818   }
1819 }
1820
1821 /// emitAbbreviations - Emit the abbreviation section.
1822 ///
1823 void DwarfDebug::emitAbbreviations() {
1824   // Check to see if it is worth the effort.
1825   if (!Abbreviations.empty()) {
1826     // Start the debug abbrev section.
1827     Asm->OutStreamer.SwitchSection(
1828                             Asm->getObjFileLowering().getDwarfAbbrevSection());
1829
1830     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1831
1832     // For each abbrevation.
1833     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1834       // Get abbreviation data
1835       const DIEAbbrev *Abbrev = Abbreviations[i];
1836
1837       // Emit the abbrevations code (base 1 index.)
1838       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1839
1840       // Emit the abbreviations data.
1841       Abbrev->Emit(Asm);
1842     }
1843
1844     // Mark end of abbreviations.
1845     Asm->EmitULEB128(0, "EOM(3)");
1846
1847     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1848   }
1849 }
1850
1851 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1852 /// the line matrix.
1853 ///
1854 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1855   // Define last address of section.
1856   Asm->OutStreamer.AddComment("Extended Op");
1857   Asm->EmitInt8(0);
1858
1859   Asm->OutStreamer.AddComment("Op size");
1860   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1861   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1862   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1863
1864   Asm->OutStreamer.AddComment("Section end label");
1865
1866   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1867                                    Asm->getDataLayout().getPointerSize(),
1868                                    0/*AddrSpace*/);
1869
1870   // Mark end of matrix.
1871   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1872   Asm->EmitInt8(0);
1873   Asm->EmitInt8(1);
1874   Asm->EmitInt8(1);
1875 }
1876
1877 /// emitAccelNames - Emit visible names into a hashed accelerator table
1878 /// section.
1879 void DwarfDebug::emitAccelNames() {
1880   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1881                                            dwarf::DW_FORM_data4));
1882   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1883          E = CUMap.end(); I != E; ++I) {
1884     CompileUnit *TheCU = I->second;
1885     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1886     for (StringMap<std::vector<DIE*> >::const_iterator
1887            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1888       const char *Name = GI->getKeyData();
1889       const std::vector<DIE *> &Entities = GI->second;
1890       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1891              DE = Entities.end(); DI != DE; ++DI)
1892         AT.AddName(Name, (*DI));
1893     }
1894   }
1895
1896   AT.FinalizeTable(Asm, "Names");
1897   Asm->OutStreamer.SwitchSection(
1898     Asm->getObjFileLowering().getDwarfAccelNamesSection());
1899   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1900   Asm->OutStreamer.EmitLabel(SectionBegin);
1901
1902   // Emit the full data.
1903   AT.Emit(Asm, SectionBegin, this);
1904 }
1905
1906 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1907 /// accelerator table section.
1908 void DwarfDebug::emitAccelObjC() {
1909   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1910                                            dwarf::DW_FORM_data4));
1911   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1912          E = CUMap.end(); I != E; ++I) {
1913     CompileUnit *TheCU = I->second;
1914     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1915     for (StringMap<std::vector<DIE*> >::const_iterator
1916            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1917       const char *Name = GI->getKeyData();
1918       const std::vector<DIE *> &Entities = GI->second;
1919       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1920              DE = Entities.end(); DI != DE; ++DI)
1921         AT.AddName(Name, (*DI));
1922     }
1923   }
1924
1925   AT.FinalizeTable(Asm, "ObjC");
1926   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1927                                  .getDwarfAccelObjCSection());
1928   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1929   Asm->OutStreamer.EmitLabel(SectionBegin);
1930
1931   // Emit the full data.
1932   AT.Emit(Asm, SectionBegin, this);
1933 }
1934
1935 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1936 /// table.
1937 void DwarfDebug::emitAccelNamespaces() {
1938   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1939                                            dwarf::DW_FORM_data4));
1940   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1941          E = CUMap.end(); I != E; ++I) {
1942     CompileUnit *TheCU = I->second;
1943     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1944     for (StringMap<std::vector<DIE*> >::const_iterator
1945            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1946       const char *Name = GI->getKeyData();
1947       const std::vector<DIE *> &Entities = GI->second;
1948       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1949              DE = Entities.end(); DI != DE; ++DI)
1950         AT.AddName(Name, (*DI));
1951     }
1952   }
1953
1954   AT.FinalizeTable(Asm, "namespac");
1955   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1956                                  .getDwarfAccelNamespaceSection());
1957   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1958   Asm->OutStreamer.EmitLabel(SectionBegin);
1959
1960   // Emit the full data.
1961   AT.Emit(Asm, SectionBegin, this);
1962 }
1963
1964 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1965 void DwarfDebug::emitAccelTypes() {
1966   std::vector<DwarfAccelTable::Atom> Atoms;
1967   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1968                                         dwarf::DW_FORM_data4));
1969   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1970                                         dwarf::DW_FORM_data2));
1971   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1972                                         dwarf::DW_FORM_data1));
1973   DwarfAccelTable AT(Atoms);
1974   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1975          E = CUMap.end(); I != E; ++I) {
1976     CompileUnit *TheCU = I->second;
1977     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1978       = TheCU->getAccelTypes();
1979     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1980            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1981       const char *Name = GI->getKeyData();
1982       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1983       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1984              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1985         AT.AddName(Name, (*DI).first, (*DI).second);
1986     }
1987   }
1988
1989   AT.FinalizeTable(Asm, "types");
1990   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1991                                  .getDwarfAccelTypesSection());
1992   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1993   Asm->OutStreamer.EmitLabel(SectionBegin);
1994
1995   // Emit the full data.
1996   AT.Emit(Asm, SectionBegin, this);
1997 }
1998
1999 void DwarfDebug::emitDebugPubTypes() {
2000   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2001          E = CUMap.end(); I != E; ++I) {
2002     CompileUnit *TheCU = I->second;
2003     // Start the dwarf pubtypes section.
2004     Asm->OutStreamer.SwitchSection(
2005       Asm->getObjFileLowering().getDwarfPubTypesSection());
2006     Asm->OutStreamer.AddComment("Length of Public Types Info");
2007     Asm->EmitLabelDifference(
2008       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
2009       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
2010
2011     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2012                                                   TheCU->getID()));
2013
2014     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2015     Asm->EmitInt16(dwarf::DWARF_VERSION);
2016
2017     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2018     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
2019                            DwarfInfoSectionSym);
2020
2021     Asm->OutStreamer.AddComment("Compilation Unit Length");
2022     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
2023                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
2024                              4);
2025
2026     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2027     for (StringMap<DIE*>::const_iterator
2028            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2029       const char *Name = GI->getKeyData();
2030       DIE *Entity = GI->second;
2031
2032       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2033       Asm->EmitInt32(Entity->getOffset());
2034
2035       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2036       // Emit the name with a terminating null byte.
2037       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
2038     }
2039
2040     Asm->OutStreamer.AddComment("End Mark");
2041     Asm->EmitInt32(0);
2042     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2043                                                   TheCU->getID()));
2044   }
2045 }
2046
2047 /// emitDebugStr - Emit visible names into a debug str section.
2048 ///
2049 void DwarfDebug::emitDebugStr() {
2050   // Check to see if it is worth the effort.
2051   if (StringPool.empty()) return;
2052
2053   // Start the dwarf str section.
2054   Asm->OutStreamer.SwitchSection(
2055                                 Asm->getObjFileLowering().getDwarfStrSection());
2056
2057   // Get all of the string pool entries and put them in an array by their ID so
2058   // we can sort them.
2059   SmallVector<std::pair<unsigned,
2060       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2061
2062   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2063        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
2064     Entries.push_back(std::make_pair(I->second.second, &*I));
2065
2066   array_pod_sort(Entries.begin(), Entries.end());
2067
2068   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2069     // Emit a label for reference from debug information entries.
2070     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2071
2072     // Emit the string itself with a terminating null byte.
2073     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2074                                          Entries[i].second->getKeyLength()+1),
2075                                0/*addrspace*/);
2076   }
2077 }
2078
2079 /// emitDebugLoc - Emit visible names into a debug loc section.
2080 ///
2081 void DwarfDebug::emitDebugLoc() {
2082   if (DotDebugLocEntries.empty())
2083     return;
2084
2085   for (SmallVector<DotDebugLocEntry, 4>::iterator
2086          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2087        I != E; ++I) {
2088     DotDebugLocEntry &Entry = *I;
2089     if (I + 1 != DotDebugLocEntries.end())
2090       Entry.Merge(I+1);
2091   }
2092
2093   // Start the dwarf loc section.
2094   Asm->OutStreamer.SwitchSection(
2095     Asm->getObjFileLowering().getDwarfLocSection());
2096   unsigned char Size = Asm->getDataLayout().getPointerSize();
2097   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2098   unsigned index = 1;
2099   for (SmallVector<DotDebugLocEntry, 4>::iterator
2100          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2101        I != E; ++I, ++index) {
2102     DotDebugLocEntry &Entry = *I;
2103     if (Entry.isMerged()) continue;
2104     if (Entry.isEmpty()) {
2105       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2106       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2107       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2108     } else {
2109       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
2110       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
2111       DIVariable DV(Entry.Variable);
2112       Asm->OutStreamer.AddComment("Loc expr size");
2113       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2114       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2115       Asm->EmitLabelDifference(end, begin, 2);
2116       Asm->OutStreamer.EmitLabel(begin);
2117       if (Entry.isInt()) {
2118         DIBasicType BTy(DV.getType());
2119         if (BTy.Verify() &&
2120             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2121              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2122           Asm->OutStreamer.AddComment("DW_OP_consts");
2123           Asm->EmitInt8(dwarf::DW_OP_consts);
2124           Asm->EmitSLEB128(Entry.getInt());
2125         } else {
2126           Asm->OutStreamer.AddComment("DW_OP_constu");
2127           Asm->EmitInt8(dwarf::DW_OP_constu);
2128           Asm->EmitULEB128(Entry.getInt());
2129         }
2130       } else if (Entry.isLocation()) {
2131         if (!DV.hasComplexAddress())
2132           // Regular entry.
2133           Asm->EmitDwarfRegOp(Entry.Loc);
2134         else {
2135           // Complex address entry.
2136           unsigned N = DV.getNumAddrElements();
2137           unsigned i = 0;
2138           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2139             if (Entry.Loc.getOffset()) {
2140               i = 2;
2141               Asm->EmitDwarfRegOp(Entry.Loc);
2142               Asm->OutStreamer.AddComment("DW_OP_deref");
2143               Asm->EmitInt8(dwarf::DW_OP_deref);
2144               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2145               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2146               Asm->EmitSLEB128(DV.getAddrElement(1));
2147             } else {
2148               // If first address element is OpPlus then emit
2149               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2150               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2151               Asm->EmitDwarfRegOp(Loc);
2152               i = 2;
2153             }
2154           } else {
2155             Asm->EmitDwarfRegOp(Entry.Loc);
2156           }
2157
2158           // Emit remaining complex address elements.
2159           for (; i < N; ++i) {
2160             uint64_t Element = DV.getAddrElement(i);
2161             if (Element == DIBuilder::OpPlus) {
2162               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2163               Asm->EmitULEB128(DV.getAddrElement(++i));
2164             } else if (Element == DIBuilder::OpDeref) {
2165               if (!Entry.Loc.isReg())
2166                 Asm->EmitInt8(dwarf::DW_OP_deref);
2167             } else
2168               llvm_unreachable("unknown Opcode found in complex address");
2169           }
2170         }
2171       }
2172       // else ... ignore constant fp. There is not any good way to
2173       // to represent them here in dwarf.
2174       Asm->OutStreamer.EmitLabel(end);
2175     }
2176   }
2177 }
2178
2179 /// emitDebugARanges - Emit visible names into a debug aranges section.
2180 ///
2181 void DwarfDebug::emitDebugARanges() {
2182   // Start the dwarf aranges section.
2183   Asm->OutStreamer.SwitchSection(
2184                           Asm->getObjFileLowering().getDwarfARangesSection());
2185 }
2186
2187 /// emitDebugRanges - Emit visible names into a debug ranges section.
2188 ///
2189 void DwarfDebug::emitDebugRanges() {
2190   // Start the dwarf ranges section.
2191   Asm->OutStreamer.SwitchSection(
2192     Asm->getObjFileLowering().getDwarfRangesSection());
2193   unsigned char Size = Asm->getDataLayout().getPointerSize();
2194   for (SmallVector<const MCSymbol *, 8>::iterator
2195          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2196        I != E; ++I) {
2197     if (*I)
2198       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2199     else
2200       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2201   }
2202 }
2203
2204 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2205 ///
2206 void DwarfDebug::emitDebugMacInfo() {
2207   if (const MCSection *LineInfo =
2208       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2209     // Start the dwarf macinfo section.
2210     Asm->OutStreamer.SwitchSection(LineInfo);
2211   }
2212 }
2213
2214 /// emitDebugInlineInfo - Emit inline info using following format.
2215 /// Section Header:
2216 /// 1. length of section
2217 /// 2. Dwarf version number
2218 /// 3. address size.
2219 ///
2220 /// Entries (one "entry" for each function that was inlined):
2221 ///
2222 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2223 ///   otherwise offset into __debug_str for regular function name.
2224 /// 2. offset into __debug_str section for regular function name.
2225 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2226 /// instances for the function.
2227 ///
2228 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2229 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2230 /// __debug_info section, and the low_pc is the starting address for the
2231 /// inlining instance.
2232 void DwarfDebug::emitDebugInlineInfo() {
2233   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2234     return;
2235
2236   if (!FirstCU)
2237     return;
2238
2239   Asm->OutStreamer.SwitchSection(
2240                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2241
2242   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2243   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2244                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2245
2246   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2247
2248   Asm->OutStreamer.AddComment("Dwarf Version");
2249   Asm->EmitInt16(dwarf::DWARF_VERSION);
2250   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2251   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2252
2253   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2254          E = InlinedSPNodes.end(); I != E; ++I) {
2255
2256     const MDNode *Node = *I;
2257     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2258       = InlineInfo.find(Node);
2259     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2260     DISubprogram SP(Node);
2261     StringRef LName = SP.getLinkageName();
2262     StringRef Name = SP.getName();
2263
2264     Asm->OutStreamer.AddComment("MIPS linkage name");
2265     if (LName.empty())
2266       Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2267     else
2268       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2269                              DwarfStrSectionSym);
2270
2271     Asm->OutStreamer.AddComment("Function name");
2272     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2273     Asm->EmitULEB128(Labels.size(), "Inline count");
2274
2275     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2276            LE = Labels.end(); LI != LE; ++LI) {
2277       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2278       Asm->EmitInt32(LI->second->getOffset());
2279
2280       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2281       Asm->OutStreamer.EmitSymbolValue(LI->first,
2282                                        Asm->getDataLayout().getPointerSize(),0);
2283     }
2284   }
2285
2286   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2287 }