lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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