lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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