Generalize debug info / EH emission in AsmPrinter

[timurrrr]

Summary

Hi David, Eric, Rafael,

Can you please review this simple patch?
See "Adding line table debug information to LLVM on Windows" for the context.

Please note that I'm very unfamiliar with the LLVM CodeGen code yet
and 12h timezones away from you.
I'd appreciate if your feedback is clear for a remote LLVM newbie, i.e. "please do this and that like this" is preferred :)

Thanks!

---

Timur Iskhodzhanov,
Google

[echristo]

Adding Dave to the reviewers as I'm sure he'll have comments as well.

[rnk]

Seems fine, but let Dave or Eric comment.

lib/CodeGen/AsmPrinter/DebugInfoEmitter.h

25 ↗

(On Diff #5662)

Is this the right name to abstract over codeview line tables, various EH impls, and general debug info? IMO it deserves a doc comment to explain what kind of thing might implement one of these.

[timurrrr]

Somewhat addressed Reid's comment

[timurrrr]

lib/CodeGen/AsmPrinter/DebugInfoEmitter.h

25 ↗

(On Diff #5662)

Is this the right name to abstract over codeview line tables, various EH impls, and general debug info?

Agree, good point.
Initially I wanted to use this interface for DI only, but it turned out I can use it for EH as well... but forgotten to update the name.

I couldn't find a good name though. AsmPrinterObserver? DebugEHInfoEmitter? Any other ideas?

IMO it deserves a doc comment to explain what kind of thing might implement one of these.

Agree, done.

[timurrrr]

David, Eric,

Any suggestions?

[timurrrr]

ping?

[echristo]

lib/CodeGen/AsmPrinter/ARMException.cpp

57 ↗

(On Diff #5674)

Renames like this should probably happen separately.

lib/CodeGen/AsmPrinter/DIE.cpp

393–395

This is what I worry about from merging the EH and Debug Info classes. This assert should never be able to fire, and while "it's just an assert" theoretically we need that assert in a lot more places.

I guess what I'm saying is that it's not obvious the assert is necessary to me. How did you run into it in the first place?

lib/CodeGen/AsmPrinter/DwarfCFIException.cpp

87 ↗

(On Diff #5674)

Ditto with the renaming here.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1816

Should be able to get rid of the MachineFunction * argument here yes?

[timurrrr]

Addressed Eric's comments

lib/CodeGen/AsmPrinter/ARMException.cpp

57 ↗

(On Diff #5674)

OK, committed as r195763.

lib/CodeGen/AsmPrinter/DIE.cpp

393–395

This code is/was the only user of getDwarfDebug() method of AP.
I'm not at all familiar with DIEEntry, but looks like it just needs to know the DWARF version being used.

It looks like before it relied on DD to exist when getRefAddrSize executes.
Frankly, I'd put something like

assert(AP->getDwarfDebug() != 0);

in this function regardless of my change.
It wasn't strictly necessary though as NULL deref would crash anyways.

That said, I believe merging EH and Debug Info has little to do with this.

I put the assert in just because I think calling getRefAddrSize() at the wrong time may silently lead to miracles.

lib/CodeGen/AsmPrinter/DwarfCFIException.cpp

87 ↗

(On Diff #5674)

Done

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1816

Good point.
I also updated a couple of more functions taking MF* as their args.

[timurrrr]

Made one more step forward and got rid of the unneeded parameter for endInstruction().

[timurrrr]

Fixed a minor formatting issue.

[timurrrr]

... and initialize CurMI in the constructor.

[timurrrr]

Post holiday ping

[echristo]

LGTM with the changes I've mentioned.

include/llvm/CodeGen/AsmPrinter.h

25

Not a huge fan of observer... maybe worker? Handler? I think I like Handler the most, but naming is hard so if you don't think it sounds better then go ahead :)

lib/CodeGen/AsmPrinter/AsmPrinterObserver.h

19

I think you want Support/DataTypes.h here?

lib/CodeGen/AsmPrinter/DIE.cpp

394

Let's make this AP->getDwarfDebug() != NULL as you mention above.

[timurrrr]

lib/CodeGen/AsmPrinter/DIE.cpp

394

The reason why I've changed that to getDwarfVersion() is that I removed getDwarfDebug entirely.
Do you think I should get it back?

[rnk]

lib/CodeGen/AsmPrinter/AsmPrinterObserver.h

19

Fun fact: stdint.h is available since MSVC 2010, so we can use it freely now. Unfortunately DataTypes.h defines other types as well. Someone should try untangling it though.

[timurrrr]

Committed as r196270, thanks for the review!

include/llvm/CodeGen/AsmPrinter.h

25

OK, Handler it is.

lib/CodeGen/AsmPrinter/AsmPrinterObserver.h

19

OK, done

lib/CodeGen/AsmPrinter/DIE.cpp

394

OK, brought getDwarfDebug() back and removed getDwarfVersion().

[timurrrr]

The change got reverted, due to beginFunction() not called by one of the subclasses of AsmPrinter.

lib/Target/R600/AMDGPUAsmPrinter.cpp

55 /// We need to override this function so we can avoid
56 /// the call to EmitFunctionHeader(), which the MCPureStreamer can't handle.
57 bool AMDGPUAsmPrinter::runOnMachineFunction(MachineFunction &MF) {

Attached is a patch that addresses that.

[timurrrr]

Since the fix is trivial enough (and resembles one of the intermediate patches), I'm going to land this.

[timurrrr]

Hopefully r196288 sticks.

include/llvm/CodeGen/AsmPrinter.h

 #define LLVM_CODEGEN_ASMPRINTER_H
 
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
+  class AsmPrinterObserver;
   class BlockAddress;
   class GCStrategy;
   class Constant;
   class ConstantArray;
   class GCMetadataPrinter;
   class GlobalValue;
   class GlobalVariable;
   class MachineBasicBlock;
private:
     ///
     bool VerboseAsm;
     static char ID;
 
     /// If VerboseAsm is set, a pointer to the loop info for this
     /// function.
     MachineLoopInfo *LI;
 
-    /// DD - If the target supports dwarf debug info, this pointer is non-null.
-    DwarfDebug *DD;
-
-    /// DE - If the target supports dwarf exception info, this pointer is
-    /// non-null.
-    DwarfException *DE;
+    struct ObserverInfo {
+      AsmPrinterObserver *Observer;
+      const char *TimerName, *TimerGroupName;
+      ObserverInfo(AsmPrinterObserver *Observer, const char *TimerName,
+                   const char *TimerGroupName)
+          : Observer(Observer), TimerName(TimerName),
+            TimerGroupName(TimerGroupName) {}
+    };
+    /// Observers - a vector of all debug/EH info emitters we should use.
+    /// This vector maintains ownership of the emitters.
+    SmallVector<ObserverInfo, 1> Observers;
+
+    /// DwarfVersion - If the target supports dwarf debug info, holds the Dwarf
+    /// Version. Otherwise, zero.
+    unsigned DwarfVersion;
 
   protected:
     explicit AsmPrinter(TargetMachine &TM, MCStreamer &Streamer);
 
   public:
     virtual ~AsmPrinter();
 
-    const DwarfDebug *getDwarfDebug() const { return DD; }
+    /// Returns the Dwarf Version or zero.
+    unsigned getDwarfVersion() const { return DwarfVersion; }
 
     /// isVerbose - Return true if assembly output should contain comments.
     ///
     bool isVerbose() const { return VerboseAsm; }
 
     /// getFunctionNumber - Return a unique ID for the current function.
     ///
     unsigned getFunctionNumber() const;

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 }
 
 AsmPrinter::AsmPrinter(TargetMachine &tm, MCStreamer &Streamer)
   : MachineFunctionPass(ID),
     TM(tm), MAI(tm.getMCAsmInfo()), MII(tm.getInstrInfo()),
     OutContext(Streamer.getContext()),
     OutStreamer(Streamer),
     LastMI(0), LastFn(0), Counter(~0U), SetCounter(0) {
-  DD = 0; DE = 0; MMI = 0; LI = 0; MF = 0;
+  MMI = 0; LI = 0; MF = 0;
+  DwarfVersion = 0;
   CurrentFnSym = CurrentFnSymForSize = 0;
   GCMetadataPrinters = 0;
   VerboseAsm = Streamer.isVerboseAsm();
 }
 
 AsmPrinter::~AsmPrinter() {
-  assert(DD == 0 && DE == 0 && "Debug/EH info didn't get finalized");
+  assert(Observers.empty() && "Debug/EH info didn't get finalized");
 
   if (GCMetadataPrinters != 0) {
     gcp_map_type &GCMap = getGCMap(GCMetadataPrinters);
 
     for (gcp_map_type::iterator I = GCMap.begin(), E = GCMap.end(); I != E; ++I)
       delete I->second;
     delete &GCMap;
     GCMetadataPrinters = 0;
bool AsmPrinter::doInitialization(Module &M) {
   if (!M.getModuleInlineAsm().empty()) {
     OutStreamer.AddComment("Start of file scope inline assembly");
     OutStreamer.AddBlankLine();
     EmitInlineAsm(M.getModuleInlineAsm()+"\n");
     OutStreamer.AddComment("End of file scope inline assembly");
     OutStreamer.AddBlankLine();
   }
 
-  if (MAI->doesSupportDebugInformation())
-    DD = new DwarfDebug(this, &M);
+  if (MAI->doesSupportDebugInformation()) {
+    DwarfDebug *DD = new DwarfDebug(this, &M);
+    DwarfVersion = DD->getDwarfVersion();
+    Observers.push_back(ObserverInfo(DD, DbgTimerName, DWARFGroupName));
+  }
 
+  DwarfException *DE = 0;
   switch (MAI->getExceptionHandlingType()) {
   case ExceptionHandling::None:
-    return false;
+    break;
   case ExceptionHandling::SjLj:
   case ExceptionHandling::DwarfCFI:
     DE = new DwarfCFIException(this);
-    return false;
+    break;
   case ExceptionHandling::ARM:
     DE = new ARMException(this);
-    return false;
+    break;
   case ExceptionHandling::Win64:
     DE = new Win64Exception(this);
-    return false;
+    break;
   }
-
-  llvm_unreachable("Unknown exception type.");
+  if (DE)
+    Observers.push_back(ObserverInfo(DE, EHTimerName, DWARFGroupName));
+  return false;
 }
 
 void AsmPrinter::EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
   GlobalValue::LinkageTypes Linkage = GV->getLinkage();
   switch (Linkage) {
   case GlobalValue::CommonLinkage:
   case GlobalValue::LinkOnceAnyLinkage:
   case GlobalValue::LinkOnceODRLinkage:
void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
   const DataLayout *DL = TM.getDataLayout();
   uint64_t Size = DL->getTypeAllocSize(GV->getType()->getElementType());
 
   // If the alignment is specified, we *must* obey it.  Overaligning a global
   // with a specified alignment is a prompt way to break globals emitted to
   // sections and expected to be contiguous (e.g. ObjC metadata).
   unsigned AlignLog = getGVAlignmentLog2(GV, *DL);
 
-  if (DD)
-    DD->setSymbolSize(GVSym, Size);
+  for (unsigned I = 0, E = Observers.size(); I != E; ++I) {
+    const ObserverInfo &OI = Observers[I];
+    NamedRegionTimer T(OI.TimerName, OI.TimerGroupName, TimePassesIsEnabled);
+    OI.Observer->setSymbolSize(GVSym, Size);
+  }
 
   // Handle common and BSS local symbols (.lcomm).
   if (GVKind.isCommon() || GVKind.isBSSLocal()) {
     if (Size == 0) Size = 1;   // .comm Foo, 0 is undefined, avoid it.
     unsigned Align = 1 << AlignLog;
 
     // Handle common symbols.
     if (GVKind.isCommon()) {
void AsmPrinter::EmitFunctionHeader() {
   std::vector<MCSymbol*> DeadBlockSyms;
   MMI->takeDeletedSymbolsForFunction(F, DeadBlockSyms);
   for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) {
     OutStreamer.AddComment("Address taken block that was later removed");
     OutStreamer.EmitLabel(DeadBlockSyms[i]);
   }
 
   // Emit pre-function debug and/or EH information.
-  if (DE) {
-    NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
-    DE->beginFunction(MF);
-  }
-  if (DD) {
-    NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
-    DD->beginFunction(MF);
+  for (unsigned I = 0, E = Observers.size(); I != E; ++I) {
+    const ObserverInfo &OI = Observers[I];
+    NamedRegionTimer T(OI.TimerName, OI.TimerGroupName, TimePassesIsEnabled);
+    OI.Observer->beginFunction(MF);
   }
 
   // Emit the prefix data.
   if (F->hasPrefixData())
     EmitGlobalConstant(F->getPrefixData());
 }
 
 /// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the

 }
 
 /// EmitFunctionBody - This method emits the body and trailer for a
 /// function.
 void AsmPrinter::EmitFunctionBody() {
   // Emit target-specific gunk before the function body.
   EmitFunctionBodyStart();
 
-  bool ShouldPrintDebugScopes = DD && MMI->hasDebugInfo();
+  bool ShouldPrintDebugScopes = MMI->hasDebugInfo();
 
   // Print out code for the function.
   bool HasAnyRealCode = false;
   const MachineInstr *LastMI = 0;
   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
        I != E; ++I) {
     // Print a label for the basic block.
     EmitBasicBlockStart(I);
     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
          II != IE; ++II) {
       LastMI = II;
 
       // Print the assembly for the instruction.
       if (!II->isLabel() && !II->isImplicitDef() && !II->isKill() &&
           !II->isDebugValue()) {
         HasAnyRealCode = true;
         ++EmittedInsts;
       }
 
       if (ShouldPrintDebugScopes) {
-        NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
-        DD->beginInstruction(II);
+        for (unsigned III = 0, EEE = Observers.size(); III != EEE; ++III) {
+          const ObserverInfo &OI = Observers[III];
+          NamedRegionTimer T(OI.TimerName, OI.TimerGroupName,
+                             TimePassesIsEnabled);
+          OI.Observer->beginInstruction(II);
+        }
       }
 
       if (isVerbose())
         emitComments(*II, OutStreamer.GetCommentOS());
 
       switch (II->getOpcode()) {
       case TargetOpcode::PROLOG_LABEL:
         emitPrologLabel(*II);
for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
         if (!TM.hasMCUseLoc())
           MCLineEntry::Make(&OutStreamer, getCurrentSection());
 
         EmitInstruction(II);
         break;
       }
 
       if (ShouldPrintDebugScopes) {
-        NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
-        DD->endInstruction(II);
+        for (unsigned III = 0, EEE = Observers.size(); III != EEE; ++III) {
+          const ObserverInfo &OI = Observers[III];
+          NamedRegionTimer T(OI.TimerName, OI.TimerGroupName,
+                             TimePassesIsEnabled);
+          OI.Observer->endInstruction(II);
+        }
       }
     }
   }
 
   // If the last instruction was a prolog label, then we have a situation where
   // we emitted a prolog but no function body. This results in the ending prolog
   // label equaling the end of function label and an invalid "row" in the
   // FDE. We need to emit a noop in this situation so that the FDE's rows are
if (MAI->hasDotTypeDotSizeDirective()) {
     const MCExpr *SizeExp =
       MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(FnEndLabel, OutContext),
                               MCSymbolRefExpr::Create(CurrentFnSymForSize,
                                                       OutContext),
                               OutContext);
     OutStreamer.EmitELFSize(CurrentFnSym, SizeExp);
   }
 
-  // Emit post-function debug information.
-  if (DD) {
-    NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
-    DD->endFunction(MF);
-  }
-  if (DE) {
-    NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
-    DE->endFunction();
+  // Emit post-function debug and/or EH information.
+  for (unsigned I = 0, E = Observers.size(); I != E; ++I) {
+    const ObserverInfo &OI = Observers[I];
+    NamedRegionTimer T(OI.TimerName, OI.TimerGroupName,
+                       TimePassesIsEnabled);
+    OI.Observer->endFunction();
   }
   MMI->EndFunction();
 
   // Print out jump tables referenced by the function.
   EmitJumpTableInfo();
 
   OutStreamer.AddBlankLine();
 }
bool AsmPrinter::doFinalization(Module &M) {
   M.getModuleFlagsMetadata(ModuleFlags);
   if (!ModuleFlags.empty())
     getObjFileLowering().emitModuleFlags(OutStreamer, ModuleFlags, Mang, TM);
 
   // Make sure we wrote out everything we need.
   OutStreamer.Flush();
 
   // Finalize debug and EH information.
-  if (DE) {
-    {
-      NamedRegionTimer T(EHTimerName, DWARFGroupName, TimePassesIsEnabled);
-      DE->endModule();
-    }
-    delete DE; DE = 0;
-  }
-  if (DD) {
-    {
-      NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
-      DD->endModule();
-    }
-    delete DD; DD = 0;
+  for (unsigned I = 0, E = Observers.size(); I != E; ++I) {
+    const ObserverInfo &OI = Observers[I];
+    NamedRegionTimer T(OI.TimerName, OI.TimerGroupName,
+                       TimePassesIsEnabled);
+    OI.Observer->endModule();
+    delete OI.Observer;
   }
+  Observers.clear();
 
   // If the target wants to know about weak references, print them all.
   if (MAI->getWeakRefDirective()) {
     // FIXME: This is not lazy, it would be nice to only print weak references
     // to stuff that is actually used.  Note that doing so would require targets
     // to notice uses in operands (due to constant exprs etc).  This should
     // happen with the MC stuff eventually.
 

lib/CodeGen/AsmPrinter/AsmPrinterObserver.h

+//===-- lib/CodeGen/AsmPrinter/AsmPrinterObserver.h ------------*- C++ -*--===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a generic interface for AsmPrinter observers,
+// like debug and EH info emitters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CODEGEN_ASMPRINTER_ASMPRINTEROBSERVER_H__
+#define CODEGEN_ASMPRINTER_ASMPRINTEROBSERVER_H__
+
+#include <stdint.h>
+
+namespace llvm {
+
+class MachineFunction;
+class MachineInstr;
+class MCSymbol;
+
+/// \brief Collects and handles AsmPrinter objects required to build debug
+/// or EH information.
+class AsmPrinterObserver {
+public:
+  virtual ~AsmPrinterObserver() {}
+
+  /// \brief For symbols that have a size designated (e.g. common symbols),
+  /// this tracks that size.
+  virtual void setSymbolSize(const MCSymbol *Sym, uint64_t Size) = 0;
+
+  /// \brief Emit all sections that should come after the content.
+  virtual void endModule() = 0;
+
+  /// \brief Gather pre-function debug information.
+  virtual void beginFunction(const MachineFunction *MF) = 0;
+
+  /// \brief Gather post-function debug information.
+  virtual void endFunction() = 0;
+
+  /// \brief Process beginning of an instruction.
+  virtual void beginInstruction(const MachineInstr *MI) = 0;
+
+  /// \brief Process end of an instruction.
+  virtual void endInstruction(const MachineInstr *MI) = 0;
+};
+} // End of namespace llvm
+
+#endif

lib/CodeGen/AsmPrinter/DIE.cpp

void DIEEntry::EmitValue(AsmPrinter *AP, dwarf::Form Form) const {
   AP->EmitInt32(Entry->getOffset());
 }
 
 unsigned DIEEntry::getRefAddrSize(AsmPrinter *AP) {
   // DWARF4: References that use the attribute form DW_FORM_ref_addr are
   // specified to be four bytes in the DWARF 32-bit format and eight bytes
   // in the DWARF 64-bit format, while DWARF Version 2 specifies that such
   // references have the same size as an address on the target system.
-  if (AP->getDwarfDebug()->getDwarfVersion() == 2)
+  unsigned DwarfVersion = AP->getDwarfVersion();
+  assert(DwarfVersion && "Expected Dwarf Debug info to be available");
+  if (DwarfVersion == 2)
     return AP->getDataLayout().getPointerSize();
   return sizeof(int32_t);
 }
 
 #ifndef NDEBUG
 void DIEEntry::print(raw_ostream &O) const {
   O << format("Die: 0x%lx", (long)(intptr_t)Entry);
 }

lib/CodeGen/AsmPrinter/DwarfDebug.h

 //===-- llvm/CodeGen/DwarfDebug.h - Dwarf Debug Framework ------*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing dwarf debug info into asm files.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CODEGEN_ASMPRINTER_DWARFDEBUG_H__
 #define CODEGEN_ASMPRINTER_DWARFDEBUG_H__
 
+#include "AsmPrinterObserver.h"
 #include "DIE.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/LexicalScopes.h"

 /// \brief Helper used to pair up a symbol and its DWARF compile unit.
 struct SymbolCU {
   SymbolCU(CompileUnit *CU, const MCSymbol *Sym) : Sym(Sym), CU(CU) {}
   const MCSymbol *Sym;
   CompileUnit *CU;
 };
 
 /// \brief Collects and handles dwarf debug information.
-class DwarfDebug {
+class DwarfDebug : public AsmPrinterObserver {
   // Target of Dwarf emission.
   AsmPrinter *Asm;
 
   // Collected machine module information.
   MachineModuleInfo *MMI;
 
   // All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
class DwarfDebug : public AsmPrinterObserver {
   // label location to indicate scope boundries in dwarf debug info.
   DebugLoc PrevInstLoc;
   MCSymbol *PrevLabel;
 
   // This location indicates end of function prologue and beginning of function
   // body.
   DebugLoc PrologEndLoc;
 
+  // If nonnull, stores the current machine function we're processing.
+  const MachineFunction *CurFn;
+
   // Section Symbols: these are assembler temporary labels that are emitted at
   // the beginning of each supported dwarf section.  These are used to form
   // section offsets and are created by EmitSectionLabels.
   MCSymbol *DwarfInfoSectionSym, *DwarfAbbrevSectionSym;
   MCSymbol *DwarfStrSectionSym, *TextSectionSym, *DwarfDebugRangeSectionSym;
   MCSymbol *DwarfDebugLocSectionSym, *DwarfLineSectionSym, *DwarfAddrSectionSym;
   MCSymbol *FunctionBeginSym, *FunctionEndSym;
   MCSymbol *DwarfAbbrevDWOSectionSym, *DwarfStrDWOSectionSym;
void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
                         unsigned Flags);
 
   /// \brief Indentify instructions that are marking the beginning of or
   /// ending of a scope.
   void identifyScopeMarkers();
 
   /// \brief If Var is an current function argument that add it in
   /// CurrentFnArguments list.
-  bool addCurrentFnArgument(const MachineFunction *MF,
-                            DbgVariable *Var, LexicalScope *Scope);
+  bool addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope);
 
   /// \brief Populate LexicalScope entries with variables' info.
-  void collectVariableInfo(const MachineFunction *,
-                           SmallPtrSet<const MDNode *, 16> &ProcessedVars);
+  void collectVariableInfo(SmallPtrSet<const MDNode *, 16> &ProcessedVars);
 
   /// \brief Collect variable information from the side table maintained
   /// by MMI.
-  void collectVariableInfoFromMMITable(const MachineFunction * MF,
-                                       SmallPtrSet<const MDNode *, 16> &P);
+  void collectVariableInfoFromMMITable(SmallPtrSet<const MDNode *, 16> &P);
 
   /// \brief Ensure that a label will be emitted before MI.
   void requestLabelBeforeInsn(const MachineInstr *MI) {
     LabelsBeforeInsn.insert(std::make_pair(MI, (MCSymbol*)0));
   }
 
   /// \brief Return Label preceding the instruction.
   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);
public:
 
   /// \brief Emit all Dwarf sections that should come after the content.
   void endModule();
 
   /// \brief Gather pre-function debug information.
   void beginFunction(const MachineFunction *MF);
 
   /// \brief Gather and emit post-function debug information.
-  void endFunction(const MachineFunction *MF);
+  void endFunction();
 
   /// \brief Process beginning of an instruction.
   void beginInstruction(const MachineInstr *MI);
 
   /// \brief Process end of an instruction.
   void endInstruction(const MachineInstr *MI);
 
   /// \brief Add a DIE to the set of types that we're going to pull into

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

: Asm(A), MMI(Asm->MMI), FirstCU(0),
                      DIEValueAllocator) {
 
   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
   DwarfStrSectionSym = TextSectionSym = 0;
   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
   DwarfAddrSectionSym = 0;
   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
   FunctionBeginSym = FunctionEndSym = 0;
+  CurFn = 0;
 
   // Turn on accelerator tables for Darwin by default, pubnames by
   // default for non-Darwin, and handle split dwarf.
   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
 
   if (DwarfAccelTables == Default)
     HasDwarfAccelTables = IsDarwin;
   else
for (unsigned ID = 0; ID < Sections.size(); ID++) {
 
     // Insert a final terminator.
     SectionMap[Section].push_back(SymbolCU(NULL, Sym));
   }
 }
 
 // Emit all Dwarf sections that should come after the content.
 void DwarfDebug::endModule() {
+  assert(CurFn == 0);
 
   if (!FirstCU)
     return;
 
   // End any existing sections.
   // TODO: Does this need to happen?
   endSections();
 
DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
 
   AbsDbgVariable = new DbgVariable(Var, NULL, this);
   addScopeVariable(Scope, AbsDbgVariable);
   AbstractVariables[Var] = AbsDbgVariable;
   return AbsDbgVariable;
 }
 
 // If Var is a current function argument then add it to CurrentFnArguments list.
-bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
-                                      DbgVariable *Var, LexicalScope *Scope) {
+bool DwarfDebug::addCurrentFnArgument(DbgVariable *Var, LexicalScope *Scope) {
   if (!LScopes.isCurrentFunctionScope(Scope))
     return false;
   DIVariable DV = Var->getVariable();
   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
     return false;
   unsigned ArgNo = DV.getArgNumber();
   if (ArgNo == 0)
     return false;
 
   size_t Size = CurrentFnArguments.size();
   if (Size == 0)
-    CurrentFnArguments.resize(MF->getFunction()->arg_size());
+    CurrentFnArguments.resize(CurFn->getFunction()->arg_size());
   // llvm::Function argument size is not good indicator of how many
   // arguments does the function have at source level.
   if (ArgNo > Size)
     CurrentFnArguments.resize(ArgNo * 2);
   CurrentFnArguments[ArgNo - 1] = Var;
   return true;
 }
 
 // Collect variable information from side table maintained by MMI.
 void DwarfDebug::collectVariableInfoFromMMITable(
-    const MachineFunction *MF, SmallPtrSet<const MDNode *, 16> &Processed) {
+    SmallPtrSet<const MDNode *, 16> &Processed) {
   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
                                                          VE = VMap.end();
        VI != VE; ++VI) {
     const MDNode *Var = VI->first;
     if (!Var)
       continue;
     Processed.insert(Var);
     DIVariable DV(Var);
     const std::pair<unsigned, DebugLoc> &VP = VI->second;
 
     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
 
     // If variable scope is not found then skip this variable.
     if (Scope == 0)
       continue;
 
     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable, this);
     RegVar->setFrameIndex(VP.first);
-    if (!addCurrentFnArgument(MF, RegVar, Scope))
+    if (!addCurrentFnArgument(RegVar, Scope))
       addScopeVariable(Scope, RegVar);
     if (AbsDbgVariable)
       AbsDbgVariable->setFrameIndex(VP.first);
   }
 }
 
 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
 // defined reg.
static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
   if (MI->getOperand(0).isCImm())
     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
 
   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
 }
 
 // Find variables for each lexical scope.
 void
-DwarfDebug::collectVariableInfo(const MachineFunction *MF,
-                                SmallPtrSet<const MDNode *, 16> &Processed) {
+DwarfDebug::collectVariableInfo(SmallPtrSet<const MDNode *, 16> &Processed) {
 
   // Grab the variable info that was squirreled away in the MMI side-table.
-  collectVariableInfoFromMMITable(MF, Processed);
+  collectVariableInfoFromMMITable(Processed);
 
   for (SmallVectorImpl<const MDNode *>::const_iterator
            UVI = UserVariables.begin(),
            UVE = UserVariables.end();
        UVI != UVE; ++UVI) {
     const MDNode *Var = *UVI;
     if (Processed.count(Var))
       continue;
 
     // History contains relevant DBG_VALUE instructions for Var and instructions
     // clobbering it.
     SmallVectorImpl<const MachineInstr *> &History = DbgValues[Var];
     if (History.empty())
       continue;
     const MachineInstr *MInsn = History.front();
 
     DIVariable DV(Var);
     LexicalScope *Scope = NULL;
     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
-        DISubprogram(DV.getContext()).describes(MF->getFunction()))
+        DISubprogram(DV.getContext()).describes(CurFn->getFunction()))
       Scope = LScopes.getCurrentFunctionScope();
     else if (MDNode *IA = DV.getInlinedAt())
       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
     else
       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
     // If variable scope is not found then skip this variable.
     if (!Scope)
       continue;
 
     Processed.insert(DV);
     assert(MInsn->isDebugValue() && "History must begin with debug value");
     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
     DbgVariable *RegVar = new DbgVariable(DV, AbsVar, this);
-    if (!addCurrentFnArgument(MF, RegVar, Scope))
+    if (!addCurrentFnArgument(RegVar, Scope))
       addScopeVariable(Scope, RegVar);
     if (AbsVar)
       AbsVar->setMInsn(MInsn);
 
     // Simplify ranges that are fully coalesced.
     if (History.size() <= 1 ||
         (History.size() == 2 && MInsn->isIdenticalTo(History.back()))) {
       RegVar->setMInsn(MInsn);
static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
   }
 
   return DebugLoc();
 }
 
 // Gather pre-function debug information.  Assumes being called immediately
 // after the function entry point has been emitted.
 void DwarfDebug::beginFunction(const MachineFunction *MF) {
+  CurFn = MF;
 
   // If there's no debug info for the function we're not going to do anything.
   if (!MMI->hasDebugInfo())
     return;
 
   // Grab the lexical scopes for the function, if we don't have any of those
   // then we're not going to be able to do anything.
   LScopes.initialize(*MF);
if (unsigned ArgNum = DV.getArgNumber()) {
     Vars.insert(I, Var);
     return;
   }
 
   Vars.push_back(Var);
 }
 
 // Gather and emit post-function debug information.
-void DwarfDebug::endFunction(const MachineFunction *MF) {
-  if (!MMI->hasDebugInfo() || LScopes.empty())
+void DwarfDebug::endFunction() {
+  assert(CurFn != 0);
+
+  if (!MMI->hasDebugInfo() || LScopes.empty()) {
+    CurFn = 0;
     return;
+  }
 
   // Define end label for subprogram.
   FunctionEndSym = Asm->GetTempSymbol("func_end", Asm->getFunctionNumber());
   // Assumes in correct section after the entry point.
   Asm->OutStreamer.EmitLabel(FunctionEndSym);
   // Set DwarfCompileUnitID in MCContext to default value.
   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
 
   SmallPtrSet<const MDNode *, 16> ProcessedVars;
-  collectVariableInfo(MF, ProcessedVars);
+  collectVariableInfo(ProcessedVars);
 
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
   assert(TheCU && "Unable to find compile unit!");
 
   // Construct abstract scopes.
   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
if (SP.isSubprogram()) {
       }
     }
     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
       constructScopeDIE(TheCU, AScope);
   }
 
   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
 
-  if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
+  if (!CurFn->getTarget().Options.DisableFramePointerElim(*CurFn))
     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
 
   // Clear debug info
   for (ScopeVariablesMap::iterator I = ScopeVariables.begin(),
                                    E = ScopeVariables.end();
        I != E; ++I)
     DeleteContainerPointers(I->second);
   ScopeVariables.clear();
   DeleteContainerPointers(CurrentFnArguments);
   UserVariables.clear();
   DbgValues.clear();
   AbstractVariables.clear();
   LabelsBeforeInsn.clear();
   LabelsAfterInsn.clear();
   PrevLabel = NULL;
+  CurFn = 0;
 }
 
 // Register a source line with debug info. Returns the  unique label that was
 // emitted and which provides correspondence to the source line list.
 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
                                   unsigned Flags) {
   StringRef Fn;
   StringRef Dir;

lib/CodeGen/AsmPrinter/DwarfException.h

 //===-- DwarfException.h - Dwarf Exception Framework -----------*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing dwarf exception info into asm files.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
 #define LLVM_CODEGEN_ASMPRINTER_DWARFEXCEPTION_H
 
+#include "AsmPrinterObserver.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include <vector>
 
 namespace llvm {
 
 template <typename T> class SmallVectorImpl;
 struct LandingPadInfo;
 class MachineModuleInfo;
 class MachineInstr;
 class MachineFunction;
 class MCAsmInfo;
 class MCExpr;
 class MCSymbol;
 class Function;
 class ARMTargetStreamer;
 class AsmPrinter;
 
 //===----------------------------------------------------------------------===//
 /// DwarfException - Emits Dwarf exception handling directives.
 ///
-class DwarfException {
+class DwarfException : public AsmPrinterObserver {
 protected:
   /// Asm - Target of Dwarf emission.
   AsmPrinter *Asm;
 
   /// MMI - Collected machine module information.
   MachineModuleInfo *MMI;
 
   /// SharedTypeIds - How many leading type ids two landing pads have in common.
public:
   virtual void endModule();
 
   /// beginFunction - Gather pre-function exception information.  Assumes being
   /// emitted immediately after the function entry point.
   virtual void beginFunction(const MachineFunction *MF);
 
   /// endFunction - Gather and emit post-function exception information.
   virtual void endFunction();
+
+  // We don't need these.
+  virtual void setSymbolSize(const MCSymbol *Sym, uint64_t Size) {}
+  virtual void beginInstruction(const MachineInstr *MI) {}
+  virtual void endInstruction(const MachineInstr *MI) {}
 };
 
 class DwarfCFIException : public DwarfException {
   /// shouldEmitPersonality - Per-function flag to indicate if .cfi_personality
   /// should be emitted.
   bool shouldEmitPersonality;
 
   /// shouldEmitLSDA - Per-function flag to indicate if .cfi_lsda