Generate DW_AT_LLVM_short_backtrace attributes for DISubprogram nodes

The Rust standard library has two [styles](https://doc.rust-lang.org/stable/std/panic/enum.BacktraceStyle.html) for printing backtraces at runtime:
1. Full backtraces. These work in the obvious way.
2. Short backtraces. These filter out "unimportant" frames that are likely not related to the developer's bug. For example, frames like `__libc_start_main`, `_Unwind_Resume`, and rust runtime internals like `std::rt::lang_start` are filtered out.

Currently, the Rust runtime determines "unimportant" frames by looking directly at un-mangled symbol names of generated functions. This is not extensible, and involves a state machine that requires the frames to be present at runtime; in particular the frames must be marked `noinline`, impeding optimizations.

This extends LLVM to encode short backtrace metadata in DWARF debuginfo. It currently does not attempt to add debuginfo to PDB, which was not designed to be extensible.

Other languages are allowed and encouraged to use this new debuginfo for their backtraces. The Rust runtime does not distinguish between producers of the debuginfo; any function with this debuginfo will be respected when printing backtraces. I hope in the future to extend `llvm-symbolizer` to have a short backtrace printing mode.

See rust-lang/compiler-team#818 for more background.

- Add a new `enum ShortBacktraceAttr { SkipFrame, StartFrame, EndFrame }`. StartFrame and EndFrame correspond to the existing `__rust_start_short_backtrace` and `__rust_end_short_backtrace` symbols. SkipFrame currently has no analogue. Each of these values is mutually exclusive with the others, and generating multiple for the same function is a logical error.
- Update all callsites of `DISubprogram::getImpl` to pass in a `std::optional<ShortBacktraceAttr>`
- Emit `ShortBacktraceAttr` when creating DWARF debuginfo. Note that this also generates debuginfo in more cases than before: When using line-tables-only debuginfo, LLVM attempts to skip functions with 0 lexical scopes. But some shims in the Rust standard library, such as `std::ops::Fn::call`, are shims that never appear in Rust source code but still appear in the backtrace. Generate info for these functions if they have a short backtrace attribute, so that they are correctly skipped in backtraces.
- Parse and serialize the new attribute in .ll files
- Add a regression test

Author: jyn514

clang/lib/CodeGen/CGDebugInfo.cpp

@@ -1786,6 +1786,7 @@ CGDebugInfo::createInlinedTrapSubprogram(StringRef FuncName,
         /*ScopeLine=*/0,
         /*Flags=*/llvm::DINode::FlagArtificial,
         /*SPFlags=*/llvm::DISubprogram::SPFlagDefinition,
+        /*ShortBacktrace=*/std::nullopt,
         /*TParams=*/nullptr, /*ThrownTypes=*/nullptr, /*Annotations=*/nullptr);
   }
 
@@ -2166,7 +2167,7 @@ llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
   llvm::DISubprogram *SP = DBuilder.createMethod(
       RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
       MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
-      TParamsArray.get());
+      std::nullopt, TParamsArray.get());
 
   SPCache[Method->getCanonicalDecl()].reset(SP);
 
@@ -4165,13 +4166,13 @@ llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
     return DBuilder.createFunction(
         DContext, Name, LinkageName, Unit, Line,
         getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
-        TParamsArray.get(), getFunctionDeclaration(FD));
+        std::nullopt, TParamsArray.get(), getFunctionDeclaration(FD));
   }
 
   llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
       DContext, Name, LinkageName, Unit, Line,
       getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
-      TParamsArray.get(), getFunctionDeclaration(FD));
+      std::nullopt, TParamsArray.get(), getFunctionDeclaration(FD));
   const FunctionDecl *CanonDecl = FD->getCanonicalDecl();
   FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
                                  std::make_tuple(CanonDecl),
@@ -4501,8 +4502,8 @@ void CGDebugInfo::emitFunctionStart(GlobalDecl GD, SourceLocation Loc,
   // are emitted as CU level entities by the backend.
   llvm::DISubprogram *SP = DBuilder.createFunction(
       FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
-      FlagsForDef, SPFlagsForDef, TParamsArray.get(), Decl, nullptr,
-      Annotations);
+      FlagsForDef, SPFlagsForDef, std::nullopt, TParamsArray.get(), Decl,
+      nullptr, Annotations);
   Fn->setSubprogram(SP);
   // We might get here with a VarDecl in the case we're generating
   // code for the initialization of globals. Do not record these decls
@@ -4565,7 +4566,7 @@ void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
   llvm::DISubroutineType *STy = getOrCreateFunctionType(D, FnType, Unit);
   llvm::DISubprogram *SP = DBuilder.createFunction(
       FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,
-      SPFlags, TParamsArray.get(), nullptr, nullptr, Annotations);
+      SPFlags, std::nullopt, TParamsArray.get(), nullptr, nullptr, Annotations);
 
   // Preserve btf_decl_tag attributes for parameters of extern functions
   // for BPF target. The parameters created in this loop are attached as

llvm/include/llvm/BinaryFormat/Dwarf.def

@@ -605,6 +605,7 @@ HANDLE_DW_AT(0x3b28, BORLAND_Delphi_ABI, 0, BORLAND)
 HANDLE_DW_AT(0x3b29, BORLAND_Delphi_return, 0, BORLAND)
 HANDLE_DW_AT(0x3b30, BORLAND_Delphi_frameptr, 0, BORLAND)
 HANDLE_DW_AT(0x3b31, BORLAND_closure, 0, BORLAND)
+
 // LLVM project extensions.
 HANDLE_DW_AT(0x3e00, LLVM_include_path, 0, LLVM)
 HANDLE_DW_AT(0x3e01, LLVM_config_macros, 0, LLVM)
@@ -619,6 +620,8 @@ HANDLE_DW_AT(0x3e09, LLVM_ptrauth_authenticates_null_values, 0, LLVM)
 HANDLE_DW_AT(0x3e0a, LLVM_ptrauth_authentication_mode, 0, LLVM)
 HANDLE_DW_AT(0x3e0b, LLVM_num_extra_inhabitants, 0, LLVM)
 HANDLE_DW_AT(0x3e0c, LLVM_stmt_sequence, 0, LLVM)
+HANDLE_DW_AT(0x3e0d, LLVM_short_backtrace, 0, LLVM)
+
 
 // Apple extensions.
 

llvm/include/llvm/IR/DIBuilder.h

@@ -808,16 +808,15 @@ namespace llvm {
     /// \param Annotations   Attribute Annotations.
     /// \param TargetFuncName The name of the target function if this is
     ///                       a trampoline.
-    DISubprogram *
-    createFunction(DIScope *Scope, StringRef Name, StringRef LinkageName,
-                   DIFile *File, unsigned LineNo, DISubroutineType *Ty,
-                   unsigned ScopeLine, DINode::DIFlags Flags = DINode::FlagZero,
-                   DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
-                   DITemplateParameterArray TParams = nullptr,
-                   DISubprogram *Decl = nullptr,
-                   DITypeArray ThrownTypes = nullptr,
-                   DINodeArray Annotations = nullptr,
-                   StringRef TargetFuncName = "");
+    DISubprogram *createFunction(
+        DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
+        unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
+        DINode::DIFlags Flags = DINode::FlagZero,
+        DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
+        std::optional<ShortBacktraceAttr> ShortBacktrace = std::nullopt,
+        DITemplateParameterArray TParams = nullptr,
+        DISubprogram *Decl = nullptr, DITypeArray ThrownTypes = nullptr,
+        DINodeArray Annotations = nullptr, StringRef TargetFuncName = "");
 
     /// Identical to createFunction,
     /// except that the resulting DbgNode is meant to be RAUWed.
@@ -826,6 +825,7 @@ namespace llvm {
         unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
         DINode::DIFlags Flags = DINode::FlagZero,
         DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
+        std::optional<ShortBacktraceAttr> ShortBacktrace = std::nullopt,
         DITemplateParameterArray TParams = nullptr,
         DISubprogram *Decl = nullptr, DITypeArray ThrownTypes = nullptr);
 
@@ -848,15 +848,15 @@ namespace llvm {
     /// \param SPFlags       Additional flags specific to subprograms.
     /// \param TParams       Function template parameters.
     /// \param ThrownTypes   Exception types this function may throw.
-    DISubprogram *
-    createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
-                 DIFile *File, unsigned LineNo, DISubroutineType *Ty,
-                 unsigned VTableIndex = 0, int ThisAdjustment = 0,
-                 DIType *VTableHolder = nullptr,
-                 DINode::DIFlags Flags = DINode::FlagZero,
-                 DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
-                 DITemplateParameterArray TParams = nullptr,
-                 DITypeArray ThrownTypes = nullptr);
+    DISubprogram *createMethod(
+        DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
+        unsigned LineNo, DISubroutineType *Ty, unsigned VTableIndex = 0,
+        int ThisAdjustment = 0, DIType *VTableHolder = nullptr,
+        DINode::DIFlags Flags = DINode::FlagZero,
+        DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
+        std::optional<ShortBacktraceAttr> ShortBacktrace = std::nullopt,
+        DITemplateParameterArray TParams = nullptr,
+        DITypeArray ThrownTypes = nullptr);
 
     /// Create common block entry for a Fortran common block.
     /// \param Scope       Scope of this common block.

llvm/include/llvm/IR/DebugInfoMetadata.h

@@ -125,6 +125,13 @@ class DITypeRefArray {
   iterator end() const { return N ? iterator(N->op_end()) : iterator(); }
 };
 
+/// DWARF-like extension attribute for setting short backtrace debuginfo.
+enum class ShortBacktraceAttr {
+  SkipFrame = 0,
+  StartShortBacktrace = 1,
+  EndShortBacktrace = 2,
+};
+
 /// Tagged DWARF-like metadata node.
 ///
 /// A metadata node with a DWARF tag (i.e., a constant named \c DW_TAG_*,
@@ -1750,35 +1757,40 @@ class DISubprogram : public DILocalScope {
 private:
   DIFlags Flags;
   DISPFlags SPFlags;
+  std::optional<ShortBacktraceAttr> ShortBacktrace;
 
   DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
                unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment,
-               DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops);
+               DIFlags Flags, DISPFlags SPFlags,
+               std::optional<ShortBacktraceAttr> ShortBacktrace,
+               ArrayRef<Metadata *> Ops);
   ~DISubprogram() = default;
 
   static DISubprogram *
   getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line,
           DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType,
           unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
-          DISPFlags SPFlags, DICompileUnit *Unit,
-          DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
-          DINodeArray RetainedNodes, DITypeArray ThrownTypes,
-          DINodeArray Annotations, StringRef TargetFuncName,
-          StorageType Storage, bool ShouldCreate = true) {
-    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
-                   getCanonicalMDString(Context, LinkageName), File, Line, Type,
-                   ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
-                   Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
-                   RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
-                   getCanonicalMDString(Context, TargetFuncName),
-                   Storage, ShouldCreate);
+          DISPFlags SPFlags, std::optional<ShortBacktraceAttr> ShortBacktrace,
+          DICompileUnit *Unit, DITemplateParameterArray TemplateParams,
+          DISubprogram *Declaration, DINodeArray RetainedNodes,
+          DITypeArray ThrownTypes, DINodeArray Annotations,
+          StringRef TargetFuncName, StorageType Storage,
+          bool ShouldCreate = true) {
+    return getImpl(
+        Context, Scope, getCanonicalMDString(Context, Name),
+        getCanonicalMDString(Context, LinkageName), File, Line, Type, ScopeLine,
+        ContainingType, VirtualIndex, ThisAdjustment, Flags, SPFlags,
+        ShortBacktrace, Unit, TemplateParams.get(), Declaration,
+        RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
+        getCanonicalMDString(Context, TargetFuncName), Storage, ShouldCreate);
   }
   static DISubprogram *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
-          int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
+          int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
+          std::optional<ShortBacktraceAttr> ShortBacktrace, Metadata *Unit,
           Metadata *TemplateParams, Metadata *Declaration,
           Metadata *RetainedNodes, Metadata *ThrownTypes, Metadata *Annotations,
           MDString *TargetFuncName, StorageType Storage,
@@ -1789,9 +1801,9 @@ class DISubprogram : public DILocalScope {
                         getFile(), getLine(), getType(), getScopeLine(),
                         getContainingType(), getVirtualIndex(),
                         getThisAdjustment(), getFlags(), getSPFlags(),
-                        getUnit(), getTemplateParams(), getDeclaration(),
-                        getRetainedNodes(), getThrownTypes(), getAnnotations(),
-                        getTargetFuncName());
+                        getShortBacktrace(), getUnit(), getTemplateParams(),
+                        getDeclaration(), getRetainedNodes(), getThrownTypes(),
+                        getAnnotations(), getTargetFuncName());
   }
 
 public:
@@ -1800,27 +1812,31 @@ class DISubprogram : public DILocalScope {
       (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File,
        unsigned Line, DISubroutineType *Type, unsigned ScopeLine,
        DIType *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
-       DIFlags Flags, DISPFlags SPFlags, DICompileUnit *Unit,
+       DIFlags Flags, DISPFlags SPFlags,
+       std::optional<ShortBacktraceAttr> ShortBacktrace, DICompileUnit *Unit,
        DITemplateParameterArray TemplateParams = nullptr,
        DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
        DITypeArray ThrownTypes = nullptr, DINodeArray Annotations = nullptr,
        StringRef TargetFuncName = ""),
       (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
-       VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
-       Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+       VirtualIndex, ThisAdjustment, Flags, SPFlags, ShortBacktrace, Unit,
+       TemplateParams, Declaration, RetainedNodes, ThrownTypes, Annotations,
+       TargetFuncName))
 
   DEFINE_MDNODE_GET(
       DISubprogram,
       (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
        unsigned Line, Metadata *Type, unsigned ScopeLine,
        Metadata *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
-       DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
+       DIFlags Flags, DISPFlags SPFlags,
+       std::optional<ShortBacktraceAttr> ShortBacktrace, Metadata *Unit,
        Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr,
        Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr,
        Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr),
       (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
-       VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
-       Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+       VirtualIndex, ThisAdjustment, Flags, SPFlags, ShortBacktrace, Unit,
+       TemplateParams, Declaration, RetainedNodes, ThrownTypes, Annotations,
+       TargetFuncName))
 
   TempDISubprogram clone() const { return cloneImpl(); }
 
@@ -1843,6 +1859,9 @@ class DISubprogram : public DILocalScope {
   }
   DIFlags getFlags() const { return Flags; }
   DISPFlags getSPFlags() const { return SPFlags; }
+  const std::optional<ShortBacktraceAttr> getShortBacktrace() const {
+    return ShortBacktrace;
+  }
   bool isLocalToUnit() const { return getSPFlags() & SPFlagLocalToUnit; }
   bool isDefinition() const { return getSPFlags() & SPFlagDefinition; }
   bool isOptimized() const { return getSPFlags() & SPFlagOptimized; }

llvm/lib/AsmParser/LLParser.cpp

@@ -5630,9 +5630,9 @@ bool LLParser::parseDICompileUnit(MDNode *&Result, bool IsDistinct) {
 ///                     isDefinition: true, scopeLine: 8, containingType: !3,
 ///                     virtuality: DW_VIRTUALTIY_pure_virtual,
 ///                     virtualIndex: 10, thisAdjustment: 4, flags: 11,
-///                     spFlags: 10, isOptimized: false, templateParams: !4,
-///                     declaration: !5, retainedNodes: !6, thrownTypes: !7,
-///                     annotations: !8)
+///                     spFlags: 10, shortBacktrace: 0, isOptimized: false,
+///                     templateParams: !4, declaration: !5, retainedNodes: !6,
+///                     thrownTypes: !7, annotations: !8)
 bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
   auto Loc = Lex.getLoc();
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
@@ -5658,10 +5658,30 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
   OPTIONAL(retainedNodes, MDField, );                                          \
   OPTIONAL(thrownTypes, MDField, );                                            \
   OPTIONAL(annotations, MDField, );                                            \
+  OPTIONAL(shortBacktrace, MDSignedField, (-1, -1, 2));                        \
   OPTIONAL(targetFuncName, MDStringField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
+  std::optional<ShortBacktraceAttr> parsedShortBacktrace;
+  switch (shortBacktrace.Val) {
+  case -1:
+    parsedShortBacktrace = std::nullopt;
+    break;
+  case 0:
+    parsedShortBacktrace = ShortBacktraceAttr::SkipFrame;
+    break;
+  case 1:
+    parsedShortBacktrace = ShortBacktraceAttr::StartShortBacktrace;
+    break;
+  case 2:
+    parsedShortBacktrace = ShortBacktraceAttr::EndShortBacktrace;
+    break;
+  default:
+    llvm_unreachable(
+        "shortBacktrace debuginfo attribute must be in range [-1, 2]");
+  }
+
   // An explicit spFlags field takes precedence over individual fields in
   // older IR versions.
   DISubprogram::DISPFlags SPFlags =
@@ -5676,9 +5696,9 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
       DISubprogram,
       (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,
        type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
-       thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
-       declaration.Val, retainedNodes.Val, thrownTypes.Val, annotations.Val,
-       targetFuncName.Val));
+       thisAdjustment.Val, flags.Val, SPFlags, parsedShortBacktrace, unit.Val,
+       templateParams.Val, declaration.Val, retainedNodes.Val, thrownTypes.Val,
+       annotations.Val, targetFuncName.Val));
   return false;
 }
 

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

@@ -1881,10 +1881,12 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
          HasThisAdj ? Record[16 + OffsetB] : 0,   // thisAdjustment
          Flags,                                   // flags
          SPFlags,                                 // SPFlags
-         HasUnit ? CUorFn : nullptr,              // unit
-         getMDOrNull(Record[13 + OffsetB]),       // templateParams
-         getMDOrNull(Record[14 + OffsetB]),       // declaration
-         getMDOrNull(Record[15 + OffsetB]),       // retainedNodes
+         // TODO: parse this from the record
+         std::nullopt,                      // shortBacktrace
+         HasUnit ? CUorFn : nullptr,        // unit
+         getMDOrNull(Record[13 + OffsetB]), // templateParams
+         getMDOrNull(Record[14 + OffsetB]), // declaration
+         getMDOrNull(Record[15 + OffsetB]), // retainedNodes
          HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
                         : nullptr, // thrownTypes
          HasAnnotations ? getMDOrNull(Record[18 + OffsetB])

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -2552,6 +2552,7 @@ void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
   // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
   // is still needed as we need its source location.
   if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
+      !SP->getShortBacktrace().has_value() &&
       TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
     for (const auto &R : Asm->MBBSectionRanges)

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

@@ -1320,6 +1320,11 @@ void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
   if (!SkipSPSourceLocation)
     addSourceLine(SPDie, SP);
 
+  if (SP->getShortBacktrace().has_value()) {
+    addUInt(SPDie, dwarf::DW_AT_LLVM_short_backtrace, dwarf::DW_FORM_data1,
+            static_cast<uint64_t>(*SP->getShortBacktrace()));
+  }
+
   // Skip the rest of the attributes under -gmlt to save space.
   if (SkipSPAttributes)
     return;

llvm/lib/IR/AsmWriter.cpp

@@ -2334,6 +2334,10 @@ static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
   Printer.printInt("thisAdjustment", N->getThisAdjustment());
   Printer.printDIFlags("flags", N->getFlags());
   Printer.printDISPFlags("spFlags", N->getSPFlags());
+  if (N->getShortBacktrace().has_value())
+    Printer.printInt("shortBacktrace",
+                     static_cast<signed>(N->getShortBacktrace().value()),
+                     /* ShouldSkipZero */ false);
   Printer.printMetadata("unit", N->getRawUnit());
   Printer.printMetadata("templateParams", N->getRawTemplateParams());
   Printer.printMetadata("declaration", N->getRawDeclaration());