lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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