lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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