make the AsmPrinterHandler array public

[vtjnash]

Summary

This lets external consumers customize the output, similar to how AssemblyAnnotationWriter lets the caller define callbacks when printing IR. The array of handlers already existed, this just cleans up the code so that it can be exposed publically.

[vtjnash]

rebase

[vtjnash]

@rnk would you be an appropriate reviewer for this idea and willing to look it over? I see @timurrrr originally created this generalization that I'm proposing exposing (r196288 / 1cd1444449cb68e2091e8f36785403288ebd3326), but that he's not working with the llvm project anymore. Thanks!

[vtjnash]

clang-format patch

[rnk]

I can take a look.

llvm/include/llvm/CodeGen/AsmPrinter.h

113

Maybe a better API for this would be to have an AsmPrinter::addAsmPrinterHandler method, so there could be more than one annotation writer.

Either way, something in-tree should either call the API or set the field. You could extend the AsmPrinterDwarfTest unit test to exercise this API.

BTW, this would be a great way to implement source code interleaving:
https://bugs.llvm.org/show_bug.cgi?id=17465
https://bugs.llvm.org/show_bug.cgi?id=39360

155

We are always managing object lifetimes in C++, so I don't think it's useful to say we are "working around the lack of a garbage collector." What this class does is to make the AsmPrinterHandler not be owned by the Handler vector.

However, I think it would be simpler to store a boolean "unowned" bit in HandlerInfo and then have the destructor check that and release the unique_ptr member.

Alternatively, maybe we can extend the lifetime of all handlers. As written, you are only extending the AAW lifetime from doFinalization to ~AsmPrinter, so there's really very little difference. I checked ~EHStreamer, ~DwarfDebug, ~CodeViewDebug, and none of them do interesting things in the destructor. Maybe you can remove the Handlers.clear() call later or remove it completely, and have standard ownership semantics, which would be best.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

319

I suppose if it were an API, you would have to supply these timer names. Bleh.

1113

This is the main change: now the handlers get called back when there is no debug info, and most of the changes are to cope with that. I'm OK with it.

[vtjnash]

update

[vtjnash]

@rnk I've generalized the API to your suggestion and added a test. Let me know what you think, thanks!

llvm/include/llvm/CodeGen/AsmPrinter.h

113

BTW, this would be a great way to implement source code interleaving:

I didn't know there were issues for it! But yeah, that's essentially what I had created this for! (I already had the code plugin to do it for arbitrary IR, so this was just exposing the equivalent surface API that I could use it here too.)

I've attempted to add a test where you described. Let me know if that looks right!

155

I went ahead and changed the API to be more general with a AsmPrinter::addAsmPrinterHandler method, and in the process did away with the need for this adapter class. I distinguish between user and ephemeral handlers by keeping track of how many are in the array, and only erasing the ones that are ephemeral while preserving those added by the user up front.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

319

Yeah, my usage only needed to add a single item, so it seemed somewhat more minimal to deal with it this way, but it seems now as simple to expose the whole struct type.

1113

Correct. Previously, it appears that the code only partially handled the notion of having multiple handlers—particularly for having the given handler enabled without having all debug information present due to the calls to the shared state setDebugInfoAvailability(false). Fortunately, there were just a few spots where those assertions needed to be removed and some conditions localized to remove that global assumption.

[rnk]

Looks good, thanks! Please implement the suggestions at your discretion before landing.

llvm/include/llvm/CodeGen/AsmPrinterHandler.h

40

Please remove the extra semicolon and reformat to add the space before the brace.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1531

Please add a comment here elaborating a bit on this. This is deleting all the handlers that AsmPrinter added, while keeping all the user-added handlers alive until the AsmPrinter is destroyed.

llvm/unittests/CodeGen/AsmPrinterDwarfTest.cpp

404 ↗

(On Diff #298649)

This is test code, but to have one less owning raw pointer, I suggest passing TestPrinter->releaseAP() here directly, and initialize the above AP variable with getAP().

[rsmith]

FYI, it looks like this broke a bunch of build bots, for example: http://lab.llvm.org:8011/#/builders/105/builds/367

[vtjnash]

Yep, I saw that too. I pushed a revert commit while I wait for the tests locally to rerun and confirm my fix for that.

[uabelho]

Hi!

Is this commit supposed to change the output from llc?

With

llc -disable-debug-info-print=true -o - unwind-tables.opt.ll

on

define i16 @main() nounwind {
entry:
  ret i16 0
}

!llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!3, !4, !5}
!llvm.ident = !{!6}

!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: LineTablesOnly, enums: !2, splitDebugInlining: false, nameTableKind: None)
!1 = !DIFile(filename: "unwind-tables.c", directory: "/tmp")
!2 = !{}
!3 = !{i32 7, !"Dwarf Version", i32 4}
!4 = !{i32 2, !"Debug Info Version", i32 3}
!5 = !{i32 1, !"wchar_size", i32 4}
!6 = !{!"clang version 12.0.0"}

I now get

.cfi_startproc
and
.cfi_endproc

in the output which I didn't before.

It seems like the behavior of -disable-debug-info-print=true has changed. Before -disable-debug-info-print=true would call MMI->setDebugInfoAvailability(false); in DwarfDebug::beginModule(), but that doesn't seem to happen anymore.

Is this expected?

[uabelho]

Bah, I meant to post my comment in https://reviews.llvm.org/D89613. I did now.

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   MachineModuleInfo *MMI = nullptr;
 
   /// This is a pointer to the current MachineLoopInfo.
   MachineDominatorTree *MDT = nullptr;
 
   /// This is a pointer to the current MachineLoopInfo.
   MachineLoopInfo *MLI = nullptr;
 
+  // Custom assembly annotations writer customizations
+  std::unique_ptr<AsmPrinterHandler> AAW;
+
   /// Optimization remark emitter.
   MachineOptimizationRemarkEmitter *ORE;
 
   MachineBlockFrequencyInfo *MBFI;
 
   ProfileSummaryInfo *PSI;
 
   /// The symbol for the entry in __patchable_function_entires.
private:
   // The garbage collection metadata printer table.
   void *GCMetadataPrinters = nullptr; // Really a DenseMap.
 
   /// Emit comments in assembly output if this is true.
   bool VerboseAsm;
 
   static char ID;
 
+  /// Simple adapter class to work around lack of a garbage collector:
+  /// this turns the expected unique_ptr back into an unmanaged pointer
+  /// wrapping our unique_ptr.
+  class AsmPrinterHandlerAdapter : public AsmPrinterHandler {
+  private:
+    AsmPrinterHandler *AAW;
+
+  public:
+    AsmPrinterHandlerAdapter(AsmPrinterHandler &AAW) : AAW(&AAW) {}
+    virtual ~AsmPrinterHandlerAdapter(){};
+    virtual void setSymbolSize(const MCSymbol *Sym, uint64_t Size) {
+      AAW->setSymbolSize(Sym, Size);
+    }
+    virtual void endModule() { AAW->endModule(); }
+    virtual void beginFunction(const MachineFunction *MF) {
+      AAW->beginFunction(MF);
+    }
+    virtual void markFunctionEnd() { AAW->markFunctionEnd(); }
+    virtual void endFunction(const MachineFunction *MF) {
+      AAW->endFunction(MF);
+    }
+    virtual void beginFragment(const MachineBasicBlock *MBB,
+                               ExceptionSymbolProvider ESP) {
+      AAW->beginFragment(MBB, ESP);
+    }
+    virtual void endFragment() { AAW->endFragment(); }
+    virtual void beginFunclet(const MachineBasicBlock &MBB, MCSymbol *Sym) {
+      AAW->beginFunclet(MBB, Sym);
+    }
+    virtual void endFunclet() { AAW->endFunclet(); }
+    virtual void beginInstruction(const MachineInstr *MI) {
+      AAW->beginInstruction(MI);
+    }
+    virtual void endInstruction() { AAW->endInstruction(); }
+    virtual void beginModule(Module *M) { AAW->beginModule(M); }
+  };
+
 protected:
   MCSymbol *CurrentFnBegin = nullptr;
 
   /// Protected struct HandlerInfo and Handlers permit target extended
   /// AsmPrinter adds their own handlers.
   struct HandlerInfo {
     std::unique_ptr<AsmPrinterHandler> Handler;
     const char *TimerName;

llvm/include/llvm/CodeGen/AsmPrinterHandler.h

 
 namespace llvm {
 
 class AsmPrinter;
 class MachineBasicBlock;
 class MachineFunction;
 class MachineInstr;
 class MCSymbol;
+class Module;
 
 typedef MCSymbol *ExceptionSymbolProvider(AsmPrinter *Asm);
 
 /// Collects and handles AsmPrinter objects required to build debug
 /// or EH information.
 class AsmPrinterHandler {
 public:
   virtual ~AsmPrinterHandler();
 
   /// 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;
 
+  virtual void beginModule(Module *M){};
+
   /// Emit all sections that should come after the content.
   virtual void endModule() = 0;
 
   /// Gather pre-function debug information.
   /// Every beginFunction(MF) call should be followed by an endFunction(MF)
   /// call.
   virtual void beginFunction(const MachineFunction *MF) = 0;
 
public:
   virtual void endFunclet() {}
 
   /// Process beginning of an instruction.
   virtual void beginInstruction(const MachineInstr *MI) = 0;
 
   /// Process end of an instruction.
   virtual void endInstruction() = 0;
 };
+
 } // End of namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/DebugHandlerBase.h

protected:
   }
 
   virtual void beginFunctionImpl(const MachineFunction *MF) = 0;
   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
   virtual void skippedNonDebugFunction() {}
 
   // AsmPrinterHandler overrides.
 public:
+  void beginModule(Module *M) override;
+
   void beginInstruction(const MachineInstr *MI) override;
   void endInstruction() override;
 
   void beginFunction(const MachineFunction *MF) override;
   void endFunction(const MachineFunction *MF) override;
 
   /// Return Label preceding the instruction.
   MCSymbol *getLabelBeforeInsn(const MachineInstr *MI);

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 static const char *const DbgTimerDescription = "Debug Info Emission";
 static const char *const EHTimerName = "write_exception";
 static const char *const EHTimerDescription = "DWARF Exception Writer";
 static const char *const CFGuardName = "Control Flow Guard";
 static const char *const CFGuardDescription = "Control Flow Guard";
 static const char *const CodeViewLineTablesGroupName = "linetables";
 static const char *const CodeViewLineTablesGroupDescription =
   "CodeView Line Tables";
+static const char *const AAWTimerName = "annotations";
+static const char *const AAWTimerDescription = "Assembly Annotations";
+static const char *const AAWGroupName = "annotations";
+static const char *const AAWGroupDescription = "Assembly Annotations";
 
 STATISTIC(EmittedInsts, "Number of machine instrs printed");
 
 char AsmPrinter::ID = 0;
 
 using gcp_map_type = DenseMap<GCStrategy *, std::unique_ptr<GCMetadataPrinter>>;
 
 static gcp_map_type &getGCMap(void *&P) {
if (!M.getModuleInlineAsm().empty()) {
     OutStreamer->AddComment("Start of file scope inline assembly");
     OutStreamer->AddBlankLine();
     EmitInlineAsm(M.getModuleInlineAsm()+"\n",
                   OutContext.getSubtargetCopy(*STI), TM.Options.MCOptions);
     OutStreamer->AddComment("End of file scope inline assembly");
     OutStreamer->AddBlankLine();
   }
 
+  if (AAW) {
+    Handlers.emplace_back(std::make_unique<AsmPrinterHandlerAdapter>(*AAW),
+                          AAWTimerName, AAWTimerDescription, AAWGroupName,
+                          AAWGroupDescription);
+  }
+
   if (MAI->doesSupportDebugInformation()) {
     bool EmitCodeView = MMI->getModule()->getCodeViewFlag();
     if (EmitCodeView && TM.getTargetTriple().isOSWindows()) {
       Handlers.emplace_back(std::make_unique<CodeViewDebug>(this),
                             DbgTimerName, DbgTimerDescription,
                             CodeViewLineTablesGroupName,
                             CodeViewLineTablesGroupDescription);
     }
     if (!EmitCodeView || MMI->getModule()->getDwarfVersion()) {
-      DD = new DwarfDebug(this, &M);
-      DD->beginModule();
+      DD = new DwarfDebug(this);
       Handlers.emplace_back(std::unique_ptr<DwarfDebug>(DD), DbgTimerName,
                             DbgTimerDescription, DWARFGroupName,
                             DWARFGroupDescription);
     }
   }
 
   switch (MAI->getExceptionHandlingType()) {
   case ExceptionHandling::SjLj:
Handlers.emplace_back(std::unique_ptr<EHStreamer>(ES), EHTimerName,
                           DWARFGroupDescription);
 
   // Emit tables for any value of cfguard flag (i.e. cfguard=1 or cfguard=2).
   if (mdconst::extract_or_null<ConstantInt>(
           MMI->getModule()->getModuleFlag("cfguard")))
     Handlers.emplace_back(std::make_unique<WinCFGuard>(this), CFGuardName,
                           CFGuardDescription, DWARFGroupName,
                           DWARFGroupDescription);
+
+  for (const HandlerInfo &HI : Handlers) {
+    NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
+                       HI.TimerGroupDescription, TimePassesIsEnabled);
+    HI.Handler->beginModule(&M);
+  }
+
   return false;
 }
 
 static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {
   if (!MAI.hasWeakDefCanBeHiddenDirective())
     return false;
 
   return GV->canBeOmittedFromSymbolTable();

 /// EmitFunctionBody - This method emits the body and trailer for a
 /// function.
 void AsmPrinter::EmitFunctionBody() {
   EmitFunctionHeader();
 
   // Emit target-specific gunk before the function body.
   EmitFunctionBodyStart();
 
-  bool ShouldPrintDebugScopes = MMI->hasDebugInfo();
-
   if (isVerbose()) {
     // Get MachineDominatorTree or compute it on the fly if it's unavailable
     MDT = getAnalysisIfAvailable<MachineDominatorTree>();
     if (!MDT) {
       OwnedMDT = std::make_unique<MachineDominatorTree>();
       OwnedMDT->getBase().recalculate(*MF);
       MDT = OwnedMDT.get();
     }
for (auto &MI : MBB) {
         HasAnyRealCode = true;
         ++NumInstsInFunction;
       }
 
       // If there is a pre-instruction symbol, emit a label for it here.
       if (MCSymbol *S = MI.getPreInstrSymbol())
         OutStreamer->EmitLabel(S);
 
-      if (ShouldPrintDebugScopes) {
-        for (const HandlerInfo &HI : Handlers) {
-          NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
-                             HI.TimerGroupName, HI.TimerGroupDescription,
-                             TimePassesIsEnabled);
-          HI.Handler->beginInstruction(&MI);
-        }
-      }
+        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
+                           HI.TimerGroupDescription, TimePassesIsEnabled);
 
       if (isVerbose())
         emitComments(MI, OutStreamer->GetCommentOS());
 
       switch (MI.getOpcode()) {
       case TargetOpcode::CFI_INSTRUCTION:
         emitCFIInstruction(MI);
         break;
for (auto &MI : MBB) {
         EmitInstruction(&MI);
         break;
       }
 
       // If there is a post-instruction symbol, emit a label for it here.
       if (MCSymbol *S = MI.getPostInstrSymbol())
         OutStreamer->EmitLabel(S);
 
-      if (ShouldPrintDebugScopes) {
-        for (const HandlerInfo &HI : Handlers) {
-          NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
-                             HI.TimerGroupName, HI.TimerGroupDescription,
-                             TimePassesIsEnabled);
-          HI.Handler->endInstruction();
-        }
-      }
-    }
+        NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
+                           HI.TimerGroupDescription, TimePassesIsEnabled);
 
     EmitBasicBlockEnd(MBB);
   }
 
   EmittedInsts += NumInstsInFunction;
   MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount",
                                       MF->getFunction().getSubprogram(),
                                       &MF->front());
bool AsmPrinter::doFinalization(Module &M) {
   }
 
   // Finalize debug and EH information.
   for (const HandlerInfo &HI : Handlers) {
     NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->endModule();
   }
   Handlers.clear();
   DD = nullptr;
 
   // 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.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 
 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {
   // If module doesn't have named metadata anchors or COFF debug section
   // is not available, skip any debug info related stuff.
   if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
       !AP->getObjFileLowering().getCOFFDebugSymbolsSection()) {
     Asm = nullptr;
-    MMI->setDebugInfoAvailability(false);
     return;
   }
   // Tell MMI that we have debug info.
   MMI->setDebugInfoAvailability(true);
 
   TheCPU =
       mapArchToCVCPUType(Triple(MMI->getModule()->getTargetTriple()).getArch());
 
void CodeViewDebug::emitCodeViewMagicVersion() {
   OS.AddComment("Debug section magic");
   OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
 }
 
 void CodeViewDebug::endModule() {
   if (!Asm || !MMI->hasDebugInfo())
     return;
 
-  assert(Asm != nullptr);
-
   // The COFF .debug$S section consists of several subsections, each starting
   // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length
   // of the payload followed by the payload itself.  The subsections are 4-byte
   // aligned.
 
   // Use the generic .debug$S section, and make a subsection for all the inlined
   // subprograms.
   switchToDebugSectionForSymbol(nullptr);

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

DbgVariableLocation::extractFromMachineInstruction(
   if (Instruction.isIndirectDebugValue())
     Location.LoadChain.push_back(Offset);
 
   return Location;
 }
 
 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
 
+void DebugHandlerBase::beginModule(Module *M) {
+  if (M->debug_compile_units().empty())
+    Asm = nullptr;
+  else
+    MMI->setDebugInfoAvailability(true);
+}
+
 // Each LexicalScope has first instruction and last instruction to mark
 // beginning and end of a scope respectively. Create an inverse map that list
 // scopes starts (and ends) with an instruction. One instruction may start (or
 // end) multiple scopes. Ignore scopes that are not reachable.
 void DebugHandlerBase::identifyScopeMarkers() {
   SmallVector<LexicalScope *, 4> WorkList;
   WorkList.push_back(LScopes.getCurrentFunctionScope());
   while (!WorkList.empty()) {
void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   }
 
   PrevInstLoc = DebugLoc();
   PrevLabel = Asm->getFunctionBegin();
   beginFunctionImpl(MF);
 }
 
 void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
-  if (!MMI->hasDebugInfo())
+  if (!Asm || !MMI->hasDebugInfo())
     return;
 
   assert(CurMI == nullptr);
   CurMI = MI;
 
   // Insert labels where requested.
   DenseMap<const MachineInstr *, MCSymbol *>::iterator I =
       LabelsBeforeInsn.find(MI);
void DebugHandlerBase::beginInstruction(const MachineInstr *MI) {
   if (!PrevLabel) {
     PrevLabel = MMI->getContext().createTempSymbol();
     Asm->OutStreamer->EmitLabel(PrevLabel);
   }
   I->second = PrevLabel;
 }
 
 void DebugHandlerBase::endInstruction() {
-  if (!MMI->hasDebugInfo())
+  if (!Asm || !MMI->hasDebugInfo())
     return;
 
   assert(CurMI != nullptr);
   // Don't create a new label after DBG_VALUE and other instructions that don't
   // generate code.
   if (!CurMI->isMetaInstruction()) {
     PrevLabel = nullptr;
     PrevInstBB = CurMI->getParent();
void DebugHandlerBase::endInstruction() {
   if (!PrevLabel) {
     PrevLabel = MMI->getContext().createTempSymbol();
     Asm->OutStreamer->EmitLabel(PrevLabel);
   }
   I->second = PrevLabel;
 }
 
 void DebugHandlerBase::endFunction(const MachineFunction *MF) {
-  if (hasDebugInfo(MMI, MF))
+  if (Asm && hasDebugInfo(MMI, MF))
     endFunctionImpl(MF);
   DbgValues.clear();
   DbgLabels.clear();
   LabelsBeforeInsn.clear();
   LabelsAfterInsn.clear();
 }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

protected:
   void endFunctionImpl(const MachineFunction *MF) override;
 
   void skippedNonDebugFunction() override;
 
 public:
   //===--------------------------------------------------------------------===//
   // Main entry points.
   //
-  DwarfDebug(AsmPrinter *A, Module *M);
+  DwarfDebug(AsmPrinter *A);
 
   ~DwarfDebug() override;
 
   /// Emit all Dwarf sections that should come prior to the
   /// content.
-  void beginModule();
+  void beginModule(Module *M) override;
 
   /// Emit all Dwarf sections that should come after the content.
   void endModule() override;
 
   /// Emits inital debug location directive.
   DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID);
 
   /// Process beginning of an instruction.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
                       cl::desc("Which DWARF linkage-name attributes to emit."),
                       cl::values(clEnumValN(DefaultLinkageNames, "Default",
                                             "Default for platform"),
                                  clEnumValN(AllLinkageNames, "All", "All"),
                                  clEnumValN(AbstractLinkageNames, "Abstract",
                                             "Abstract subprograms")),
                       cl::init(DefaultLinkageNames));
 
-static const char *const DWARFGroupName = "dwarf";
-static const char *const DWARFGroupDescription = "DWARF Emission";
-static const char *const DbgTimerName = "writer";
-static const char *const DbgTimerDescription = "DWARF Debug Writer";
 static constexpr unsigned ULEB128PadSize = 4;
 
 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
   getActiveStreamer().EmitInt8(
       Op, Comment ? Twine(Comment) + " " + dwarf::OperationEncodingString(Op)
                   : dwarf::OperationEncodingString(Op));
 }
 
static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
   if (DwarfVersion >= 5)
     return AccelTableKind::Dwarf;
   if (Tuning == DebuggerKind::LLDB)
     return TT.isOSBinFormatMachO() ? AccelTableKind::Apple
                                    : AccelTableKind::Dwarf;
   return AccelTableKind::None;
 }
 
-DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
+DwarfDebug::DwarfDebug(AsmPrinter *A)
     : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
       InfoHolder(A, "info_string", DIEValueAllocator),
       SkeletonHolder(A, "skel_string", DIEValueAllocator),
       IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
   const Triple &TT = Asm->TM.getTargetTriple();
 
   // Make sure we know our "debugger tuning".  The target option takes
   // precedence; fall back to triple-based defaults.
GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
                          }),
              GVEs.end());
   return GVEs;
 }
 
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
-void DwarfDebug::beginModule() {
-  NamedRegionTimer T(DbgTimerName, DbgTimerDescription, DWARFGroupName,
-                     DWARFGroupDescription, TimePassesIsEnabled);
-  if (DisableDebugInfoPrinting) {
-    MMI->setDebugInfoAvailability(false);
-    return;
-  }
+void DwarfDebug::beginModule(Module *M) {
+  DebugHandlerBase::beginModule(M);
 
-  const Module *M = MMI->getModule();
+  if (!Asm || !MMI->hasDebugInfo() || DisableDebugInfoPrinting)
+    return;
 
   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
                                        M->debug_compile_units_end());
-  // Tell MMI whether we have debug info.
-  assert(MMI->hasDebugInfo() == (NumDebugCUs > 0) &&
-         "DebugInfoAvailabilty initialized unexpectedly");
+  assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
+  assert(MMI->hasDebugInfo() &&
+         "DebugInfoAvailabilty unexpectedly not initialized");
   SingleCU = NumDebugCUs == 1;
   DenseMap<DIGlobalVariable *, SmallVector<DwarfCompileUnit::GlobalExpr, 1>>
       GVMap;
   for (const GlobalVariable &Global : M->globals()) {
     SmallVector<DIGlobalVariableExpression *, 1> GVs;
     Global.getDebugInfo(GVs);
     for (auto *GVE : GVs)
       GVMap[GVE->getVariable()].push_back({&Global, GVE->getExpression()});
void DwarfDebug::endModule() {
   for (const auto &P : CUMap) {
     auto &CU = *P.second;
     CU.createBaseTypeDIEs();
   }
 
   // If we aren't actually generating debug info (check beginModule -
   // conditionalized on !DisableDebugInfoPrinting and the presence of the
   // llvm.dbg.cu metadata node)
-  if (!MMI->hasDebugInfo())
+  if (!Asm || !MMI->hasDebugInfo() || DisableDebugInfoPrinting)
     return;
 
   // Finalize the debug info for the module.
   finalizeModuleInfo();
 
   emitDebugStr();
 
   if (useSplitDwarf())
for (const DINode *DN : SP->getRetainedNodes()) {
     if (Scope)
       createConcreteEntity(TheCU, *Scope, DN, nullptr);
   }
 }
 
 // Process beginning of an instruction.
 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   DebugHandlerBase::beginInstruction(MI);
-  assert(CurMI);
+  if (!CurMI)
+    return;
 
   const auto *SP = MI->getMF()->getFunction().getSubprogram();
   if (!SP || SP->getUnit()->getEmissionKind() == DICompileUnit::NoDebug)
     return;
 
   // Check if source location changes, but ignore DBG_VALUE and CFI locations.
   // If the instruction is part of the function frame setup code, do not emit
   // any line record, as there is no correspondence with any user code.

llvm/lib/CodeGen/MachineModuleInfo.cpp

 // Handle the Pass registration stuff necessary to use DataLayout's.
 INITIALIZE_PASS(MachineModuleInfoWrapperPass, "machinemoduleinfo",
                 "Machine Module Information", false, false)
 char MachineModuleInfoWrapperPass::ID = 0;
 
 bool MachineModuleInfoWrapperPass::doInitialization(Module &M) {
   MMI.initialize();
   MMI.TheModule = &M;
-  MMI.DbgInfoAvailable = !M.debug_compile_units().empty();
+  MMI.DbgInfoAvailable = false;
   return false;
 }
 
 bool MachineModuleInfoWrapperPass::doFinalization(Module &M) {
   MMI.finalize();
   return false;
 }
 
 AnalysisKey MachineModuleAnalysis::Key;
 
 MachineModuleInfo MachineModuleAnalysis::run(Module &M,
                                              ModuleAnalysisManager &) {
   MachineModuleInfo MMI(TM);
   MMI.TheModule = &M;
-  MMI.DbgInfoAvailable = !M.debug_compile_units().empty();
+  MMI.DbgInfoAvailable = false;
   return MMI;
 }

llvm/lib/Target/BPF/BTFDebug.cpp

void BTFDebug::beginInstruction(const MachineInstr *MI) {
   } else if (MI->getOpcode() == BPF::JAL) {
     // check extern function references
     const MachineOperand &MO = MI->getOperand(0);
     if (MO.isGlobal()) {
       processFuncPrototypes(dyn_cast<Function>(MO.getGlobal()));
     }
   }
 
+  if (!CurMI) // no debug info
+    return;
+
   // Skip this instruction if no DebugLoc or the DebugLoc
   // is the same as the previous instruction.
   const DebugLoc &DL = MI->getDebugLoc();
   if (!DL || PrevInstLoc == DL) {
     // This instruction will be skipped, no LineInfo has
     // been generated, construct one based on function signature.
     if (LineInfoGenerated == false) {
       auto *S = MI->getMF()->getFunction().getSubprogram();