lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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