lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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