Auto merge of #134831 - jyn514:backtrace-debuginfo, r=<try>

[experimental] shorten backtraces using debuginfo

cc rust-lang/compiler-team#818

r? `@ghost`

`@rustbot` label S-experimental

try-job: aarch64-apple

Author: bors

Cargo.lock

@@ -3525,6 +3525,7 @@ dependencies = [
  "bitflags",
  "cc",
  "either",
+ "gimli 0.31.1",
  "itertools",
  "libc",
  "object 0.36.7",

compiler/rustc_codegen_cranelift/src/debuginfo/mod.rs

@@ -15,7 +15,7 @@ use gimli::write::{
 };
 use gimli::{AArch64, Encoding, Format, LineEncoding, Register, RiscV, RunTimeEndian, X86_64};
 use indexmap::IndexSet;
-use rustc_codegen_ssa::debuginfo::type_names;
+use rustc_codegen_ssa::debuginfo::{DW_AT_short_backtrace, DW_short_backtrace_value, type_names};
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefIdMap;
 use rustc_session::Session;
@@ -239,6 +239,16 @@ impl DebugContext {
         entry.set(gimli::DW_AT_decl_file, AttributeValue::FileIndex(Some(file_id)));
         entry.set(gimli::DW_AT_decl_line, AttributeValue::Udata(line));
 
+        if let Some(skip) = tcx.codegen_fn_attrs(instance.def_id()).skip_short_backtrace {
+            tracing::info!(
+                "debuginfo {:?}: skip_short_backtrace={:?}",
+                tcx.item_name(instance.def_id()),
+                skip
+            );
+            let attr = AttributeValue::Data1(DW_short_backtrace_value(skip));
+            entry.set(gimli::DwAt(DW_AT_short_backtrace), attr);
+        }
+
         if !fn_abi.ret.is_ignore() {
             let return_dw_ty = self.debug_type(tcx, type_dbg, fn_abi.ret.layout.ty);
             let entry = self.dwarf.unit.get_mut(entry_id);

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -27,6 +27,7 @@ extern crate rustc_metadata;
 extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
+extern crate tracing;
 
 // This prevents duplicating functions and statics that are already part of the host rustc process.
 #[allow(unused_extern_crates)]

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -34,7 +34,7 @@ use crate::common::{AsCCharPtr, CodegenCx};
 use crate::llvm;
 use crate::llvm::debuginfo::{
     DIArray, DIBuilder, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope, DIType,
-    DIVariable,
+    DIVariable, ShortBacktraceKind,
 };
 use crate::value::Value;
 
@@ -375,6 +375,16 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             }
         }
 
+        // If appropriate, mark the function as skippable in backtraces.
+        let skip = self.tcx.codegen_fn_attrs(instance.def_id()).skip_short_backtrace;
+        if let Some(s) = skip {
+            tracing::info!(
+                "generate short backtrace {s:?} for {}",
+                tcx.item_name(instance.def_id())
+            );
+        }
+        let skip = ShortBacktraceKind::from_generic(skip);
+
         // When we're adding a method to a type DIE, we only want a DW_AT_declaration there, because
         // LLVM LTO can't unify type definitions when a child DIE is a full subprogram definition.
         // When we use this `decl` below, the subprogram definition gets created at the CU level
@@ -392,6 +402,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 function_type_metadata,
                 flags,
                 spflags & !DISPFlags::SPFlagDefinition,
+                skip,
                 template_parameters,
             )
         });
@@ -410,6 +421,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
                 scope_line,
                 flags,
                 spflags,
+                skip,
                 maybe_definition_llfn,
                 template_parameters,
                 decl,

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -5,6 +5,7 @@ use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::ptr;
 
+use debuginfo::ShortBacktraceKind;
 use libc::{c_char, c_int, c_uint, c_ulonglong, c_void, size_t};
 use rustc_macros::TryFromU32;
 use rustc_target::spec::SymbolVisibility;
@@ -707,6 +708,7 @@ pub type InlineAsmDiagHandlerTy = unsafe extern "C" fn(&SMDiagnostic, *const c_v
 
 pub mod debuginfo {
     use bitflags::bitflags;
+    use rustc_middle::middle::codegen_fn_attrs::SkipShortBacktrace;
 
     use super::{InvariantOpaque, Metadata};
 
@@ -775,6 +777,27 @@ pub mod debuginfo {
         }
     }
 
+    /// LLVMRustDebugEmissionKind
+    #[derive(Copy, Clone, Debug)]
+    #[repr(C)]
+    pub enum ShortBacktraceKind {
+        SkipFrame,
+        StartShortBacktrace,
+        EndShortBacktrace,
+        None,
+    }
+
+    impl ShortBacktraceKind {
+        pub fn from_generic(opt: Option<SkipShortBacktrace>) -> Self {
+            match opt {
+                None => ShortBacktraceKind::None,
+                Some(SkipShortBacktrace::ThisFrameOnly) => ShortBacktraceKind::SkipFrame,
+                Some(SkipShortBacktrace::Start) => ShortBacktraceKind::StartShortBacktrace,
+                Some(SkipShortBacktrace::End) => ShortBacktraceKind::EndShortBacktrace,
+            }
+        }
+    }
+
     /// LLVMRustDebugEmissionKind
     #[derive(Copy, Clone)]
     #[repr(C)]
@@ -1891,6 +1914,7 @@ unsafe extern "C" {
         ScopeLine: c_uint,
         Flags: DIFlags,
         SPFlags: DISPFlags,
+        ShortBacktrace: ShortBacktraceKind,
         MaybeFn: Option<&'a Value>,
         TParam: &'a DIArray,
         Decl: Option<&'a DIDescriptor>,
@@ -1908,6 +1932,7 @@ unsafe extern "C" {
         Ty: &'a DIType,
         Flags: DIFlags,
         SPFlags: DISPFlags,
+        ShortBacktrace: ShortBacktraceKind,
         TParam: &'a DIArray,
     ) -> &'a DISubprogram;
 

compiler/rustc_codegen_ssa/Cargo.toml

@@ -12,6 +12,7 @@ bitflags = "2.4.1"
 # `cc` in `rustc_llvm` if you update the `cc` here.
 cc = "=1.2.5"
 either = "1.5.0"
+gimli = "0.31.1"
 itertools = "0.12"
 pathdiff = "0.2.0"
 regex = "1.4"

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -9,7 +9,7 @@ use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::weak_lang_items::WEAK_LANG_ITEMS;
 use rustc_hir::{self as hir, HirId, LangItem, lang_items};
 use rustc_middle::middle::codegen_fn_attrs::{
-    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry,
+    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, SkipShortBacktrace,
 };
 use rustc_middle::mir::mono::Linkage;
 use rustc_middle::query::Providers;
@@ -581,6 +581,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
     });
 
+    codegen_fn_attrs.skip_short_backtrace = SkipShortBacktrace::lookup(tcx, did);
+
     // #73631: closures inherit `#[target_feature]` annotations
     //
     // If this closure is marked `#[inline(always)]`, simply skip adding `#[target_feature]`.
@@ -643,6 +645,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     // Additionally weak lang items have predetermined symbol names.
     if WEAK_LANG_ITEMS.iter().any(|&l| tcx.lang_items().get(l) == Some(did.to_def_id())) {
         codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
+        codegen_fn_attrs.skip_short_backtrace = Some(SkipShortBacktrace::ThisFrameOnly);
     }
     if let Some((name, _)) = lang_items::extract(attrs)
         && let Some(lang_item) = LangItem::from_name(name)

compiler/rustc_codegen_ssa/src/debuginfo/mod.rs

@@ -6,6 +6,25 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
 // FIXME(eddyb) find a place for this (or a way to replace it).
 pub mod type_names;
 
+#[allow(non_upper_case_globals)]
+mod short_backtraces {
+    use rustc_middle::middle::codegen_fn_attrs::SkipShortBacktrace;
+
+    // This is effectively public API. Don't change it.
+    pub const DW_AT_short_backtrace: u16 = 0x3c00;
+    pub const DW_FORM_short_backtrace: u16 = gimli::constants::DW_FORM_data1.0;
+
+    #[allow(non_snake_case)]
+    pub fn DW_short_backtrace_value(fn_attr: SkipShortBacktrace) -> u8 {
+        match fn_attr {
+            SkipShortBacktrace::ThisFrameOnly => 0,
+            SkipShortBacktrace::Start => 1,
+            SkipShortBacktrace::End => 2,
+        }
+    }
+}
+pub use short_backtraces::*;
+
 /// Returns true if we want to generate a DW_TAG_enumeration_type description for
 /// this instead of a DW_TAG_struct_type with DW_TAG_variant_part.
 ///

compiler/rustc_feature/src/builtin_attrs.rs

@@ -684,6 +684,18 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_allocator_zeroed, Normal, template!(Word), WarnFollowing,
         EncodeCrossCrate::No, IMPL_DETAIL
     ),
+    rustc_attr!(
+        rustc_skip_short_backtrace, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::No, IMPL_DETAIL,
+    ),
+    rustc_attr!(
+        rustc_start_short_backtrace, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::No, IMPL_DETAIL,
+    ),
+    rustc_attr!(
+        rustc_end_short_backtrace, Normal, template!(Word), WarnFollowing,
+        EncodeCrossCrate::No, IMPL_DETAIL,
+    ),
     gated!(
         default_lib_allocator, Normal, template!(Word), WarnFollowing,
         EncodeCrossCrate::No, allocator_internals, experimental!(default_lib_allocator),

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -822,6 +822,31 @@ static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
   return Result;
 }
 
+// These values **must** match debuginfo::ShortBacktrace! They also *happen*
+// to match LLVM, but that isn't required as we do giant sets of
+// matching below. The value shouldn't be directly passed to LLVM.
+enum class LLVMRustShortBacktrace {
+  SkipFrame,
+  StartShortBacktrace,
+  EndShortBacktrace,
+  None,
+};
+
+static std::optional<ShortBacktraceAttr> shortBacktraceFromRust(LLVMRustShortBacktrace backtrace) {
+  switch (backtrace) {
+    case LLVMRustShortBacktrace::SkipFrame:
+      return ShortBacktraceAttr::SkipFrame;
+    case LLVMRustShortBacktrace::StartShortBacktrace:
+      return ShortBacktraceAttr::StartShortBacktrace;
+    case LLVMRustShortBacktrace::EndShortBacktrace:
+      return ShortBacktraceAttr::EndShortBacktrace;
+    case LLVMRustShortBacktrace::None:
+      return std::nullopt;
+    default:
+      report_fatal_error("bad ShortBacktraceAttr.");
+  }
+}
+
 enum class LLVMRustDebugEmissionKind {
   NoDebug,
   FullDebug,
@@ -1016,16 +1041,18 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
     size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
     LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
     unsigned ScopeLine, LLVMRustDIFlags Flags, LLVMRustDISPFlags SPFlags,
-    LLVMValueRef MaybeFn, LLVMMetadataRef TParam, LLVMMetadataRef Decl) {
+    LLVMRustShortBacktrace shortBacktrace, LLVMValueRef MaybeFn, LLVMMetadataRef TParam,
+    LLVMMetadataRef Decl) {
   DITemplateParameterArray TParams =
       DITemplateParameterArray(unwrap<MDTuple>(TParam));
   DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
   DINode::DIFlags llvmFlags = fromRust(Flags);
   DISubprogram *Sub = Builder->createFunction(
       unwrapDI<DIScope>(Scope), StringRef(Name, NameLen),
       StringRef(LinkageName, LinkageNameLen), unwrapDI<DIFile>(File), LineNo,
-      unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags, llvmSPFlags,
-      TParams, unwrapDIPtr<DISubprogram>(Decl));
+      unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
+      llvmSPFlags, shortBacktraceFromRust(shortBacktrace), TParams,
+      unwrapDIPtr<DISubprogram>(Decl));
   if (MaybeFn)
     unwrap<Function>(MaybeFn)->setSubprogram(Sub);
   return wrap(Sub);
@@ -1035,7 +1062,8 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
     size_t NameLen, const char *LinkageName, size_t LinkageNameLen,
     LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty,
-    LLVMRustDIFlags Flags, LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) {
+    LLVMRustDIFlags Flags, LLVMRustDISPFlags SPFlags, LLVMRustShortBacktrace shortBacktrace,
+    LLVMMetadataRef TParam) {
   DITemplateParameterArray TParams =
       DITemplateParameterArray(unwrap<MDTuple>(TParam));
   DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
@@ -1045,7 +1073,7 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
       StringRef(LinkageName, LinkageNameLen), unwrapDI<DIFile>(File), LineNo,
       unwrapDI<DISubroutineType>(Ty), 0, 0,
       nullptr, // VTable params aren't used
-      llvmFlags, llvmSPFlags, TParams);
+      llvmFlags, llvmSPFlags, shortBacktraceFromRust(shortBacktrace), TParams);
   return wrap(Sub);
 }
 

compiler/rustc_middle/messages.ftl

@@ -83,6 +83,9 @@ middle_limit_invalid =
     `limit` must be a non-negative integer
     .label = {$error_str}
 
+middle_multiple_short_backtrace_attrs = multiple `#[rustc_*_short_backtrace]` attributes were used on the same item
+    .note = "attribute used here"
+
 middle_opaque_hidden_type_mismatch =
     concrete type differs from previous defining opaque type use
     .label = expected `{$self_ty}`, got `{$other_ty}`

compiler/rustc_middle/src/middle/codegen_fn_attrs.rs

@@ -1,10 +1,11 @@
 use rustc_abi::Align;
 use rustc_attr_parsing::{InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable};
-use rustc_span::Symbol;
+use rustc_span::{Symbol, sym};
 use rustc_target::spec::SanitizerSet;
 
 use crate::mir::mono::Linkage;
+use crate::ty::TyCtxt;
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, Debug)]
 pub struct CodegenFnAttrs {
@@ -49,6 +50,9 @@ pub struct CodegenFnAttrs {
     /// The `#[patchable_function_entry(...)]` attribute. Indicates how many nops should be around
     /// the function entry.
     pub patchable_function_entry: Option<PatchableFunctionEntry>,
+    /// Whether to generate debuginfo that instructs libstd's panic handler to
+    /// skip this frame when printing short backtraces.
+    pub skip_short_backtrace: Option<SkipShortBacktrace>,
 }
 
 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
@@ -83,6 +87,62 @@ impl PatchableFunctionEntry {
     }
 }
 
+// #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
+#[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
+pub enum SkipShortBacktrace {
+    ThisFrameOnly,
+    Start,
+    End,
+}
+
+#[derive(Diagnostic)]
+#[diag(middle_multiple_short_backtrace_attrs)]
+struct MultipleShortBacktraceAttrs {
+    #[primary_span]
+    #[label]
+    pub span: Span,
+    #[note]
+    start: Option<Span>,
+    #[note]
+    end: Option<Span>,
+    #[note]
+    skip: Option<Span>,
+}
+
+impl SkipShortBacktrace {
+    pub fn lookup(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<SkipShortBacktrace> {
+        let skip = tcx.get_attr(def_id, sym::rustc_skip_short_backtrace);
+        let start = tcx.get_attr(def_id, sym::rustc_start_short_backtrace);
+        let end = tcx.get_attr(def_id, sym::rustc_end_short_backtrace);
+
+        // TODO: need to add a visitor somewhere that errors if this is applied other than to a module or function
+
+        let kind = match (skip.is_some(), start.is_some(), end.is_some()) {
+            (true, false, false) => SkipShortBacktrace::ThisFrameOnly,
+            (false, true, false) => SkipShortBacktrace::Start,
+            (false, false, true) => SkipShortBacktrace::End,
+            (false, false, false) => {
+                let parent_mod = tcx.parent_module_from_def_id(def_id);
+                if tcx.get_attr(parent_mod, sym::rustc_skip_short_backtrace).is_some() {
+                    SkipShortBacktrace::ThisFrameOnly
+                } else {
+                    return None;
+                }
+            }
+            _ => {
+                tcx.dcx().emit_err(MultipleShortBacktraceAttrs {
+                    span: tcx.def_span(def_id),
+                    skip: skip.map(|attr| attr.span),
+                    start: start.map(|attr| attr.span),
+                    end: end.map(|attr| attr.span),
+                });
+                return None;
+            }
+        };
+        Some(kind)
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, Eq, TyEncodable, TyDecodable, HashStable)]
 pub struct CodegenFnAttrFlags(u32);
 bitflags::bitflags! {
@@ -156,6 +216,7 @@ impl CodegenFnAttrs {
             instruction_set: None,
             alignment: None,
             patchable_function_entry: None,
+            skip_short_backtrace: None,
         }
     }