lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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