1use std::borrow::Cow;
2use std::fmt::{self, Write};
3use std::hash::{Hash, Hasher};
4use std::path::PathBuf;
5use std::{assert_matches, iter, ptr};
6
7use libc::{c_longlong, c_uint};
8use rustc_abi::{Align, Endian, Layout, NumScalableVectors, Size};
9use rustc_ast::{IntTy, UintTy};
10use rustc_codegen_ssa::debuginfo::type_names::{VTableNameKind, cpp_like_debuginfo};
11use rustc_codegen_ssa::traits::*;
12use rustc_hir::def::{CtorKind, DefKind};
13use rustc_hir::def_id::{DefId, LOCAL_CRATE};
14use rustc_middle::ty::layout::{
15 HasTypingEnv, LayoutOf, TyAndLayout, WIDE_PTR_ADDR, WIDE_PTR_EXTRA,
16};
17use rustc_middle::ty::{
18 self, AdtDef, AdtKind, ExistentialTraitRef, Instance, Ty, TyCtxt, Unnormalized, Visibility,
19};
20use rustc_session::config::{self, DebugInfo, Lto};
21use rustc_span::{
22 DUMMY_SP, FileName, RemapPathScopeComponents, SourceFile, Span, Symbol, bug, hygiene,
23};
24use rustc_symbol_mangling::typeid_for_trait_ref;
25use rustc_target::spec::{Arch, DebuginfoKind, HasTargetSpec};
26use smallvec::smallvec;
27use tracing::{debug, instrument};
28
29pub(crate) use self::type_map::TypeMap;
30use self::type_map::{DINodeCreationResult, Stub, UniqueTypeId};
31use super::CodegenUnitDebugContext;
32use super::namespace::mangled_name_of_instance;
33use super::type_names::{compute_debuginfo_type_name, compute_debuginfo_vtable_name};
34use super::utils::{DIB, debug_context, get_namespace_for_item, is_node_local_to_unit};
35use crate::common::CodegenCx;
36use crate::debuginfo::metadata::type_map::build_type_with_children;
37use crate::debuginfo::utils::{WidePtrKind, create_DIArray, wide_pointer_kind};
38use crate::debuginfo::{DIBuilderExt, dwarf_const};
39use crate::llvm::debuginfo::{
40 DIBasicType, DIBuilder, DICompositeType, DIDescriptor, DIFile, DIFlags, DILexicalBlock,
41 DIScope, DIType, DebugEmissionKind, DebugNameTableKind,
42};
43use crate::llvm::{self, FromGeneric, Value};
44
45impl PartialEq for llvm::Metadata {
46 fn eq(&self, other: &Self) -> bool {
47 ptr::eq(self, other)
48 }
49}
50
51impl Eq for llvm::Metadata {}
52
53impl Hash for llvm::Metadata {
54 fn hash<H: Hasher>(&self, hasher: &mut H) {
55 (self as *const Self).hash(hasher);
56 }
57}
58
59impl fmt::Debug for llvm::Metadata {
60 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
61 (self as *const Self).fmt(f)
62 }
63}
64
65pub(super) const UNKNOWN_LINE_NUMBER: c_uint = 0;
66pub(super) const UNKNOWN_COLUMN_NUMBER: c_uint = 0;
67
68const NO_SCOPE_METADATA: Option<&DIScope> = None;
69const NO_GENERICS: for<'ll> fn(&CodegenCx<'ll, '_>) -> SmallVec<Option<&'ll DIType>> =
71 |_| SmallVec::new();
72
73type SmallVec<T> = smallvec::SmallVec<[T; 16]>;
76
77mod enums;
78mod type_map;
79
80macro_rules! return_if_di_node_created_in_meantime {
83 ($cx: expr, $unique_type_id: expr) => {
84 if let Some(di_node) = debug_context($cx).type_map.di_node_for_unique_id($unique_type_id) {
85 return DINodeCreationResult::new(di_node, true);
86 }
87 };
88}
89
90#[inline]
92fn size_and_align_of(ty_and_layout: TyAndLayout<'_>) -> (Size, Align) {
93 (ty_and_layout.size, ty_and_layout.align)
94}
95
96fn build_fixed_size_array_di_node<'ll, 'tcx>(
99 cx: &CodegenCx<'ll, 'tcx>,
100 unique_type_id: UniqueTypeId<'tcx>,
101 array_type: Ty<'tcx>,
102 span: Span,
103) -> DINodeCreationResult<'ll> {
104 let ty::Array(element_type, len) = array_type.kind() else {
105 ::rustc_span::macros::bug_impl(None,
format_args!("build_fixed_size_array_di_node() called with non-ty::Array type `{0:?}`",
array_type), Location::caller())bug!("build_fixed_size_array_di_node() called with non-ty::Array type `{:?}`", array_type)
106 };
107
108 let element_type_di_node = spanned_type_di_node(cx, *element_type, span);
109
110 if let Some(di_node) =
debug_context(cx).type_map.di_node_for_unique_id(unique_type_id) {
return DINodeCreationResult::new(di_node, true);
};return_if_di_node_created_in_meantime!(cx, unique_type_id);
111
112 let (size, align) = cx.spanned_size_and_align_of(array_type, span);
113
114 let upper_bound = len
115 .try_to_target_usize(cx.tcx)
116 .expect("expected monomorphic const in codegen") as c_longlong;
117
118 let subrange = unsafe { llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound) };
119 let subscripts = &[subrange];
120
121 let di_node = unsafe {
122 llvm::LLVMDIBuilderCreateArrayType(
123 DIB(cx),
124 size.bits(),
125 align.bits() as u32,
126 element_type_di_node,
127 subscripts.as_ptr(),
128 subscripts.len() as c_uint,
129 )
130 };
131
132 DINodeCreationResult::new(di_node, false)
133}
134
135fn build_pointer_or_reference_di_node<'ll, 'tcx>(
144 cx: &CodegenCx<'ll, 'tcx>,
145 ptr_type: Ty<'tcx>,
146 pointee_type: Ty<'tcx>,
147 unique_type_id: UniqueTypeId<'tcx>,
148 span: Span,
149) -> DINodeCreationResult<'ll> {
150 {
match (&cx.size_and_align_of(ptr_type),
&cx.size_and_align_of(Ty::new_mut_ptr(cx.tcx, pointee_type))) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(
153 cx.size_and_align_of(ptr_type),
154 cx.size_and_align_of(Ty::new_mut_ptr(cx.tcx, pointee_type))
155 );
156
157 let pointee_type_di_node = match pointee_type.kind() {
158 ty::Slice(element_type) => spanned_type_di_node(cx, *element_type, span),
160 ty::Str => type_di_node(cx, cx.tcx.types.u8),
162
163 _ => spanned_type_di_node(cx, pointee_type, span),
170 };
171
172 if let Some(di_node) =
debug_context(cx).type_map.di_node_for_unique_id(unique_type_id) {
return DINodeCreationResult::new(di_node, true);
};return_if_di_node_created_in_meantime!(cx, unique_type_id);
173
174 let data_layout = &cx.tcx.data_layout;
175 let pointer_size = data_layout.pointer_size();
176 let pointer_align = data_layout.pointer_align();
177 let ptr_type_debuginfo_name = compute_debuginfo_type_name(cx.tcx, ptr_type, true);
178
179 match wide_pointer_kind(cx, pointee_type) {
180 None => {
181 {
match (&(pointer_size, pointer_align), &cx.size_and_align_of(ptr_type)) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val,
::core::option::Option::Some(format_args!("ptr_type={0}, pointee_type={1}",
ptr_type, pointee_type)));
}
}
}
};assert_eq!(
183 (pointer_size, pointer_align),
184 cx.size_and_align_of(ptr_type),
185 "ptr_type={ptr_type}, pointee_type={pointee_type}",
186 );
187
188 let di_node = create_pointer_type(
189 cx,
190 pointee_type_di_node,
191 pointer_size,
192 pointer_align,
193 &ptr_type_debuginfo_name,
194 );
195
196 DINodeCreationResult { di_node, already_stored_in_typemap: false }
197 }
198 Some(wide_pointer_kind) => {
199 type_map::build_type_with_children(
200 cx,
201 type_map::stub(
202 cx,
203 Stub::Struct,
204 unique_type_id,
205 &ptr_type_debuginfo_name,
206 None,
207 cx.size_and_align_of(ptr_type),
208 NO_SCOPE_METADATA,
209 DIFlags::FlagZero,
210 ),
211 |cx, owner| {
212 let layout_type = if ptr_type.is_box() {
220 Ty::new_mut_ptr(cx.tcx, pointee_type)
224 } else {
225 ptr_type
226 };
227
228 let layout = cx.layout_of(layout_type);
229 let addr_field = layout.field(cx, WIDE_PTR_ADDR);
230 let extra_field = layout.field(cx, WIDE_PTR_EXTRA);
231
232 let (addr_field_name, extra_field_name) = match wide_pointer_kind {
233 WidePtrKind::Dyn => ("pointer", "vtable"),
234 WidePtrKind::Slice => ("data_ptr", "length"),
235 };
236
237 {
match (&WIDE_PTR_ADDR, &0) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(WIDE_PTR_ADDR, 0);
238 {
match (&WIDE_PTR_EXTRA, &1) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(WIDE_PTR_EXTRA, 1);
239
240 let data_ptr_type_di_node = create_pointer_type(
243 cx,
244 pointee_type_di_node,
245 addr_field.size,
246 addr_field.align,
247 "",
248 );
249
250 {
let count = 0usize + 1usize + 1usize;
let mut vec = ::smallvec::SmallVec::new();
if count <= vec.inline_size() {
vec.push(build_field_di_node(cx, owner, addr_field_name, addr_field,
layout.fields.offset(WIDE_PTR_ADDR), DIFlags::FlagZero,
data_ptr_type_di_node, None));
vec.push(build_field_di_node(cx, owner, extra_field_name, extra_field,
layout.fields.offset(WIDE_PTR_EXTRA), DIFlags::FlagZero,
type_di_node(cx, extra_field.ty), None));
vec
} else {
::smallvec::SmallVec::from_vec(::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
[build_field_di_node(cx, owner, addr_field_name, addr_field,
layout.fields.offset(WIDE_PTR_ADDR), DIFlags::FlagZero,
data_ptr_type_di_node, None),
build_field_di_node(cx, owner, extra_field_name,
extra_field, layout.fields.offset(WIDE_PTR_EXTRA),
DIFlags::FlagZero, type_di_node(cx, extra_field.ty),
None)])))
}
}smallvec![
251 build_field_di_node(
252 cx,
253 owner,
254 addr_field_name,
255 addr_field,
256 layout.fields.offset(WIDE_PTR_ADDR),
257 DIFlags::FlagZero,
258 data_ptr_type_di_node,
259 None,
260 ),
261 build_field_di_node(
262 cx,
263 owner,
264 extra_field_name,
265 extra_field,
266 layout.fields.offset(WIDE_PTR_EXTRA),
267 DIFlags::FlagZero,
268 type_di_node(cx, extra_field.ty),
269 None,
270 ),
271 ]
272 },
273 NO_GENERICS,
274 )
275 }
276 }
277}
278
279fn build_subroutine_type_di_node<'ll, 'tcx>(
280 cx: &CodegenCx<'ll, 'tcx>,
281 unique_type_id: UniqueTypeId<'tcx>,
282) -> DINodeCreationResult<'ll> {
283 debug_context(cx)
296 .type_map
297 .unique_id_to_di_node
298 .borrow_mut()
299 .insert(unique_type_id, recursion_marker_type_di_node(cx));
300
301 let fn_ty = unique_type_id.expect_ty();
302 let signature =
303 cx.tcx.normalize_erasing_late_bound_regions(cx.typing_env(), fn_ty.fn_sig(cx.tcx));
304
305 let signature_di_nodes: SmallVec<_> = iter::once(
306 match signature.output().kind() {
308 ty::Tuple(tys) if tys.is_empty() => {
309 None
311 }
312 _ => Some(type_di_node(cx, signature.output())),
313 },
314 )
315 .chain(
316 signature.inputs().iter().map(|&argument_type| Some(type_di_node(cx, argument_type))),
318 )
319 .collect();
320
321 debug_context(cx).type_map.unique_id_to_di_node.borrow_mut().remove(&unique_type_id);
322
323 let fn_di_node = create_subroutine_type(cx, &signature_di_nodes[..]);
324
325 let name = compute_debuginfo_type_name(cx.tcx, fn_ty, false);
327 let (size, align) = match fn_ty.kind() {
328 ty::FnDef(..) => (Size::ZERO, Align::ONE),
329 ty::FnPtr(..) => (cx.tcx.data_layout.pointer_size(), cx.tcx.data_layout.pointer_align()),
330 _ => ::core::panicking::unreachable_default_msg()unreachable!(),
331 };
332 let di_node = create_pointer_type(cx, fn_di_node, size, align, &name);
333
334 DINodeCreationResult::new(di_node, false)
335}
336
337pub(super) fn create_subroutine_type<'ll>(
338 cx: &CodegenCx<'ll, '_>,
339 signature: &[Option<&'ll llvm::Metadata>],
340) -> &'ll DICompositeType {
341 unsafe {
342 llvm::LLVMDIBuilderCreateSubroutineType(
343 DIB(cx),
344 None, signature.as_ptr(),
346 signature.len() as c_uint,
347 DIFlags::FlagZero, )
349 }
350}
351
352fn create_pointer_type<'ll>(
353 cx: &CodegenCx<'ll, '_>,
354 pointee_ty: &'ll llvm::Metadata,
355 size: Size,
356 align: Align,
357 name: &str,
358) -> &'ll llvm::Metadata {
359 unsafe {
360 llvm::LLVMDIBuilderCreatePointerType(
361 DIB(cx),
362 pointee_ty,
363 size.bits(),
364 align.bits() as u32,
365 0, name.as_ptr(),
367 name.len(),
368 )
369 }
370}
371
372fn build_dyn_type_di_node<'ll, 'tcx>(
375 cx: &CodegenCx<'ll, 'tcx>,
376 dyn_type: Ty<'tcx>,
377 unique_type_id: UniqueTypeId<'tcx>,
378) -> DINodeCreationResult<'ll> {
379 if let ty::Dynamic(..) = dyn_type.kind() {
380 let type_name = compute_debuginfo_type_name(cx.tcx, dyn_type, true);
381 type_map::build_type_with_children(
382 cx,
383 type_map::stub(
384 cx,
385 Stub::Struct,
386 unique_type_id,
387 &type_name,
388 None,
389 cx.size_and_align_of(dyn_type),
390 NO_SCOPE_METADATA,
391 DIFlags::FlagZero,
392 ),
393 |_, _| ::smallvec::SmallVec::new()smallvec![],
394 NO_GENERICS,
395 )
396 } else {
397 ::rustc_span::macros::bug_impl(None,
format_args!("Only ty::Dynamic is valid for build_dyn_type_di_node(). Found {0:?} instead.",
dyn_type), Location::caller())bug!(
398 "Only ty::Dynamic is valid for build_dyn_type_di_node(). Found {:?} instead.",
399 dyn_type
400 )
401 }
402}
403
404fn build_slice_type_di_node<'ll, 'tcx>(
406 cx: &CodegenCx<'ll, 'tcx>,
407 slice_type: Ty<'tcx>,
408 unique_type_id: UniqueTypeId<'tcx>,
409 span: Span,
410) -> DINodeCreationResult<'ll> {
411 let element_type = match slice_type.kind() {
412 ty::Slice(element_type) => *element_type,
413 ty::Str => cx.tcx.types.u8,
414 _ => {
415 ::rustc_span::macros::bug_impl(None,
format_args!("Only ty::Slice is valid for build_slice_type_di_node(). Found {0:?} instead.",
slice_type), Location::caller())bug!(
416 "Only ty::Slice is valid for build_slice_type_di_node(). Found {:?} instead.",
417 slice_type
418 )
419 }
420 };
421
422 let element_type_di_node = type_di_node(cx, element_type);
423 if let Some(di_node) =
debug_context(cx).type_map.di_node_for_unique_id(unique_type_id) {
return DINodeCreationResult::new(di_node, true);
};return_if_di_node_created_in_meantime!(cx, unique_type_id);
424 let (size, align) = cx.spanned_size_and_align_of(slice_type, span);
425 let subrange = unsafe { llvm::LLVMDIBuilderGetOrCreateSubrange(DIB(cx), 0, -1) };
426 let subscripts = &[subrange];
427 let di_node = unsafe {
428 llvm::LLVMDIBuilderCreateArrayType(
429 DIB(cx),
430 size.bits(),
431 align.bits() as u32,
432 element_type_di_node,
433 subscripts.as_ptr(),
434 subscripts.len() as c_uint,
435 )
436 };
437 DINodeCreationResult { di_node, already_stored_in_typemap: false }
438}
439
440pub(crate) fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
445 spanned_type_di_node(cx, t, DUMMY_SP)
446}
447
448pub(crate) fn spanned_type_di_node<'ll, 'tcx>(
449 cx: &CodegenCx<'ll, 'tcx>,
450 t: Ty<'tcx>,
451 span: Span,
452) -> &'ll DIType {
453 let unique_type_id = UniqueTypeId::for_ty(cx.tcx, t);
454
455 if let Some(existing_di_node) = debug_context(cx).type_map.di_node_for_unique_id(unique_type_id)
456 {
457 return existing_di_node;
458 }
459
460 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:460",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(460u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&["message"],
::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("type_di_node: {0:?} kind: {1:?}",
t, t.kind()) as &dyn ::tracing::field::Value))])
});
} else { ; }
};debug!("type_di_node: {:?} kind: {:?}", t, t.kind());
461
462 let DINodeCreationResult { di_node, already_stored_in_typemap } = match *t.kind() {
463 ty::Never | ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) => {
464 build_basic_type_di_node(cx, t)
465 }
466 ty::Tuple(elements) if elements.is_empty() => build_basic_type_di_node(cx, t),
467 ty::Array(..) => build_fixed_size_array_di_node(cx, unique_type_id, t, span),
468 ty::Slice(_) | ty::Str => build_slice_type_di_node(cx, t, unique_type_id, span),
469 ty::Dynamic(..) => build_dyn_type_di_node(cx, t, unique_type_id),
470 ty::Foreign(..) => build_foreign_type_di_node(cx, t, unique_type_id),
471 ty::RawPtr(pointee_type, _) | ty::Ref(_, pointee_type, _) => {
472 build_pointer_or_reference_di_node(cx, t, pointee_type, unique_type_id, span)
473 }
474 ty::Adt(def, args)
478 if def.is_box()
479 && args.get(1).is_none_or(|arg| cx.layout_of(arg.expect_ty()).is_1zst()) =>
480 {
481 build_pointer_or_reference_di_node(cx, t, t.expect_boxed_ty(), unique_type_id, span)
482 }
483 ty::FnDef(..) | ty::FnPtr(..) => build_subroutine_type_di_node(cx, unique_type_id),
484 ty::Closure(..) => build_closure_env_di_node(cx, unique_type_id),
485 ty::CoroutineClosure(..) => build_closure_env_di_node(cx, unique_type_id),
486 ty::Coroutine(..) => enums::build_coroutine_di_node(cx, unique_type_id),
487 ty::Adt(def, ..) => match def.adt_kind() {
488 AdtKind::Struct => build_struct_type_di_node(cx, unique_type_id, span),
489 AdtKind::Union => build_union_type_di_node(cx, unique_type_id, span),
490 AdtKind::Enum => enums::build_enum_type_di_node(cx, unique_type_id, span),
491 },
492 ty::Tuple(_) => build_tuple_type_di_node(cx, unique_type_id),
493 ty::Pat(base, _) => return type_di_node(cx, base),
494 ty::UnsafeBinder(_) => build_unsafe_binder_type_di_node(cx, t, unique_type_id),
495 ty::Alias(..)
496 | ty::Param(_)
497 | ty::Bound(..)
498 | ty::Infer(_)
499 | ty::Placeholder(_)
500 | ty::CoroutineWitness(..)
501 | ty::Error(_) => {
502 ::rustc_span::macros::bug_impl(None,
format_args!("debuginfo: unexpected type in type_di_node(): {0:?}", t),
Location::caller())bug!("debuginfo: unexpected type in type_di_node(): {:?}", t)
503 }
504
505 ty::View(..) => ::core::panicking::unimplemented_default_msg()unimplemented!(),
507 };
508
509 {
510 if already_stored_in_typemap {
511 let di_node_for_uid =
513 match debug_context(cx).type_map.di_node_for_unique_id(unique_type_id) {
514 Some(di_node) => di_node,
515 None => {
516 ::rustc_span::macros::bug_impl(None,
format_args!("expected type debuginfo node for unique type ID \'{0:?}\' to already be in the `debuginfo::TypeMap` but it was not.",
unique_type_id), Location::caller());bug!(
517 "expected type debuginfo node for unique \
518 type ID '{:?}' to already be in \
519 the `debuginfo::TypeMap` but it \
520 was not.",
521 unique_type_id,
522 );
523 }
524 };
525
526 {
match (&(di_node_for_uid as *const _), &(di_node as *const _)) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(di_node_for_uid as *const _, di_node as *const _);
527 } else {
528 debug_context(cx).type_map.insert(unique_type_id, di_node);
529 }
530 }
531
532 di_node
533}
534
535fn recursion_marker_type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>) -> &'ll DIType {
537 debug_context(cx).recursion_marker_type.get_or_init(move || {
538 create_basic_type(
549 cx,
550 "<recur_type>",
551 cx.tcx.data_layout.pointer_size(),
552 dwarf_const::DW_ATE_unsigned,
553 )
554 })
555}
556
557fn hex_encode(data: &[u8]) -> String {
558 let mut hex_string = String::with_capacity(data.len() * 2);
559 for byte in data.iter() {
560 (&mut hex_string).write_fmt(format_args!("{0:02x}", byte))write!(&mut hex_string, "{byte:02x}").unwrap();
561 }
562 hex_string
563}
564
565pub(crate) fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) -> &'ll DIFile {
566 let cache_key = Some((source_file.stable_id, source_file.src_hash));
567 return debug_context(cx)
568 .created_files
569 .borrow_mut()
570 .entry(cache_key)
571 .or_insert_with(|| alloc_new_file_metadata(cx, source_file));
572
573 {}
#[allow(clippy :: suspicious_else_formatting)]
{
let __tracing_attr_span;
let __tracing_attr_guard;
if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() ||
{ false } {
__tracing_attr_span =
{
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("alloc_new_file_metadata",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(573u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&[],
::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::SPAN)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let mut interest = ::tracing::subscriber::Interest::never();
if ::tracing::Level::DEBUG <=
::tracing::level_filters::STATIC_MAX_LEVEL &&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{ interest = __CALLSITE.interest(); !interest.is_never() }
&&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest) {
let meta = __CALLSITE.metadata();
::tracing::Span::new(meta,
&{ meta.fields().value_set_all(&[]) })
} else {
let span =
::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
{};
span
}
};
__tracing_attr_guard = __tracing_attr_span.enter();
}
#[warn(clippy :: suspicious_else_formatting)]
{
#[allow(unknown_lints, unreachable_code, clippy ::
diverging_sub_expression, clippy :: empty_loop, clippy ::
let_unit_value, clippy :: let_with_type_underscore, clippy ::
needless_return, clippy :: unreachable)]
if false {
let __tracing_attr_fake_return: &'ll DIFile = loop {};
return __tracing_attr_fake_return;
}
{
{
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:578",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(578u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&[{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("source_file.name")
}> =
::tracing::__macro_support::FieldName::new("source_file.name");
NAME.as_str()
}], ::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <=
::tracing::level_filters::STATIC_MAX_LEVEL &&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&source_file.name)
as &dyn ::tracing::field::Value))])
});
} else { ; }
};
let (directory, file_name) =
match &source_file.name {
FileName::Real(filename) => {
let (working_directory, embeddable_name) =
filename.embeddable_name(RemapPathScopeComponents::DEBUGINFO);
{
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:585",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(585u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&[{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("working_directory")
}> =
::tracing::__macro_support::FieldName::new("working_directory");
NAME.as_str()
},
{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("embeddable_name")
}> =
::tracing::__macro_support::FieldName::new("embeddable_name");
NAME.as_str()
}], ::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <=
::tracing::level_filters::STATIC_MAX_LEVEL &&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&working_directory)
as &dyn ::tracing::field::Value)),
(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&embeddable_name)
as &dyn ::tracing::field::Value))])
});
} else { ; }
};
if let Ok(rel_path) =
embeddable_name.strip_prefix(working_directory) {
(working_directory.to_string_lossy(),
rel_path.to_string_lossy().into_owned())
} else {
("".into(), embeddable_name.to_string_lossy().into_owned())
}
}
other => {
{
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:610",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(610u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&[{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("other")
}> =
::tracing::__macro_support::FieldName::new("other");
NAME.as_str()
}], ::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <=
::tracing::level_filters::STATIC_MAX_LEVEL &&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&other)
as &dyn ::tracing::field::Value))])
});
} else { ; }
};
("".into(),
other.display(RemapPathScopeComponents::DEBUGINFO).to_string())
}
};
let hash_kind =
match source_file.src_hash.kind {
rustc_span::SourceFileHashAlgorithm::Md5 =>
llvm::ChecksumKind::MD5,
rustc_span::SourceFileHashAlgorithm::Sha1 =>
llvm::ChecksumKind::SHA1,
rustc_span::SourceFileHashAlgorithm::Sha256 =>
llvm::ChecksumKind::SHA256,
rustc_span::SourceFileHashAlgorithm::Blake3 =>
llvm::ChecksumKind::None,
};
let hash_value = hex_encode(source_file.src_hash.hash_bytes());
let mut source = None;
let external_src;
if cx.sess().opts.unstable_opts.embed_source {
source = source_file.src.as_deref().map(String::as_str);
if source.is_none() {
cx.tcx.sess.source_map().ensure_source_file_source_present(source_file);
external_src = source_file.external_src.read();
source = external_src.get_source();
}
}
create_file(DIB(cx), &file_name, &directory, &hash_value,
hash_kind, source)
}
}
}#[instrument(skip(cx, source_file), level = "debug")]
574 fn alloc_new_file_metadata<'ll>(
575 cx: &CodegenCx<'ll, '_>,
576 source_file: &SourceFile,
577 ) -> &'ll DIFile {
578 debug!(?source_file.name);
579
580 let (directory, file_name) = match &source_file.name {
581 FileName::Real(filename) => {
582 let (working_directory, embeddable_name) =
583 filename.embeddable_name(RemapPathScopeComponents::DEBUGINFO);
584
585 debug!(?working_directory, ?embeddable_name);
586
587 if let Ok(rel_path) = embeddable_name.strip_prefix(working_directory) {
588 (working_directory.to_string_lossy(), rel_path.to_string_lossy().into_owned())
605 } else {
606 ("".into(), embeddable_name.to_string_lossy().into_owned())
607 }
608 }
609 other => {
610 debug!(?other);
611 ("".into(), other.display(RemapPathScopeComponents::DEBUGINFO).to_string())
612 }
613 };
614
615 let hash_kind = match source_file.src_hash.kind {
616 rustc_span::SourceFileHashAlgorithm::Md5 => llvm::ChecksumKind::MD5,
617 rustc_span::SourceFileHashAlgorithm::Sha1 => llvm::ChecksumKind::SHA1,
618 rustc_span::SourceFileHashAlgorithm::Sha256 => llvm::ChecksumKind::SHA256,
619 rustc_span::SourceFileHashAlgorithm::Blake3 => llvm::ChecksumKind::None,
620 };
621 let hash_value = hex_encode(source_file.src_hash.hash_bytes());
622
623 let mut source = None;
624 let external_src;
625 if cx.sess().opts.unstable_opts.embed_source {
626 source = source_file.src.as_deref().map(String::as_str);
627 if source.is_none() {
628 cx.tcx.sess.source_map().ensure_source_file_source_present(source_file);
629 external_src = source_file.external_src.read();
630 source = external_src.get_source();
631 }
632 }
633
634 create_file(DIB(cx), &file_name, &directory, &hash_value, hash_kind, source)
635 }
636}
637
638fn unknown_file_metadata<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll DIFile {
639 debug_context(cx).created_files.borrow_mut().entry(None).or_insert_with(|| {
640 create_file(DIB(cx), "<unknown>", "", "", llvm::ChecksumKind::None, None)
641 })
642}
643
644fn create_file<'ll>(
645 builder: &DIBuilder<'ll>,
646 file_name: &str,
647 directory: &str,
648 hash_value: &str,
649 hash_kind: llvm::ChecksumKind,
650 source: Option<&str>,
651) -> &'ll DIFile {
652 unsafe {
653 llvm::LLVMRustDIBuilderCreateFile(
654 builder,
655 file_name.as_ptr(),
656 file_name.len(),
657 directory.as_ptr(),
658 directory.len(),
659 hash_kind,
660 hash_value.as_ptr(),
661 hash_value.len(),
662 source.map_or(ptr::null(), |x| x.as_ptr()),
663 source.map_or(0, |x| x.len()),
664 )
665 }
666}
667
668trait MsvcBasicName {
669 fn msvc_basic_name(self) -> &'static str;
670}
671
672impl MsvcBasicName for ty::IntTy {
673 fn msvc_basic_name(self) -> &'static str {
674 match self {
675 ty::IntTy::Isize => "ptrdiff_t",
676 ty::IntTy::I8 => "__int8",
677 ty::IntTy::I16 => "__int16",
678 ty::IntTy::I32 => "__int32",
679 ty::IntTy::I64 => "__int64",
680 ty::IntTy::I128 => "__int128",
681 }
682 }
683}
684
685impl MsvcBasicName for ty::UintTy {
686 fn msvc_basic_name(self) -> &'static str {
687 match self {
688 ty::UintTy::Usize => "size_t",
689 ty::UintTy::U8 => "unsigned __int8",
690 ty::UintTy::U16 => "unsigned __int16",
691 ty::UintTy::U32 => "unsigned __int32",
692 ty::UintTy::U64 => "unsigned __int64",
693 ty::UintTy::U128 => "unsigned __int128",
694 }
695 }
696}
697
698fn build_cpp_float_struct_di_node<'ll, 'tcx>(
701 cx: &CodegenCx<'ll, 'tcx>,
702 float_ty: Ty<'tcx>,
703 bits_ty: Ty<'tcx>,
704 bits_names: &[&str],
705) -> DINodeCreationResult<'ll> {
706 if true {
if !#[allow(non_exhaustive_omitted_patterns)] match bits_ty.kind() {
ty::Uint(_) => true,
_ => false,
} {
::core::panicking::panic("assertion failed: matches!(bits_ty.kind(), ty::Uint(_))")
};
};debug_assert!(matches!(bits_ty.kind(), ty::Uint(_)));
707 if true {
{
match (&(cx.size_of(bits_ty) * (bits_names.len() as u64)),
&cx.size_of(float_ty)) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};
};debug_assert_eq!(cx.size_of(bits_ty) * (bits_names.len() as u64), cx.size_of(float_ty));
708 let name = if let ty::Float(f) = float_ty.kind() {
711 f.name_str()
712 } else {
713 ::rustc_span::macros::bug_impl(None,
format_args!("{0:?} was not a float", float_ty), Location::caller());bug!("{float_ty:?} was not a float");
714 };
715 type_map::build_type_with_children(
716 cx,
717 type_map::stub(
718 cx,
719 Stub::Struct,
720 UniqueTypeId::for_ty(cx.tcx, float_ty),
721 name,
722 None,
723 cx.size_and_align_of(float_ty),
724 NO_SCOPE_METADATA,
725 DIFlags::FlagZero,
726 ),
727 |cx, float_di_node| {
729 let bits_layout = cx.layout_of(bits_ty);
730 let bits_node = type_di_node(cx, bits_ty);
731 bits_names
732 .iter()
733 .copied()
734 .enumerate()
735 .map(|(i, field_name)| {
736 build_field_di_node(
737 cx,
738 float_di_node,
739 field_name,
740 bits_layout,
741 bits_layout.size * (i as u64),
742 DIFlags::FlagZero,
743 bits_node,
744 None,
745 )
746 })
747 .collect()
748 },
749 NO_GENERICS,
750 )
751}
752
753fn build_basic_type_di_node<'ll, 'tcx>(
754 cx: &CodegenCx<'ll, 'tcx>,
755 t: Ty<'tcx>,
756) -> DINodeCreationResult<'ll> {
757 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:757",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(757u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&["message"],
::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("build_basic_type_di_node: {0:?}",
t) as &dyn ::tracing::field::Value))])
});
} else { ; }
};debug!("build_basic_type_di_node: {:?}", t);
758
759 let cpp_like_debuginfo = cpp_like_debuginfo(cx.tcx);
762
763 use dwarf_const::{DW_ATE_UTF, DW_ATE_boolean, DW_ATE_float, DW_ATE_signed, DW_ATE_unsigned};
764
765 let (name, encoding) = match t.kind() {
766 ty::Never => ("!", DW_ATE_unsigned),
767 ty::Tuple(elements) if elements.is_empty() => {
768 if cpp_like_debuginfo {
769 return build_tuple_type_di_node(cx, UniqueTypeId::for_ty(cx.tcx, t));
770 } else {
771 ("()", DW_ATE_unsigned)
772 }
773 }
774 ty::Bool => ("bool", DW_ATE_boolean),
775 ty::Char => ("char", DW_ATE_UTF),
776 ty::Int(int_ty) if cpp_like_debuginfo => (int_ty.msvc_basic_name(), DW_ATE_signed),
777 ty::Uint(uint_ty) if cpp_like_debuginfo => (uint_ty.msvc_basic_name(), DW_ATE_unsigned),
778 ty::Float(ty::FloatTy::F16) if cpp_like_debuginfo => {
779 return build_cpp_float_struct_di_node(cx, t, cx.tcx.types.u16, &["bits"]);
780 }
781 ty::Float(ty::FloatTy::F128) if cpp_like_debuginfo => {
782 {
match (&cx.target_spec().endian, &Endian::Little) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(cx.target_spec().endian, Endian::Little);
784 return build_cpp_float_struct_di_node(
785 cx,
786 t,
787 cx.tcx.types.u64,
788 &["low_bits", "high_bits"],
789 );
790 }
791 ty::Float(ty::FloatTy::F32) if cpp_like_debuginfo => ("float", DW_ATE_float),
792 ty::Float(ty::FloatTy::F64) if cpp_like_debuginfo => ("double", DW_ATE_float),
793 ty::Int(int_ty) => (int_ty.name_str(), DW_ATE_signed),
794 ty::Uint(uint_ty) => (uint_ty.name_str(), DW_ATE_unsigned),
795 ty::Float(float_ty) => (float_ty.name_str(), DW_ATE_float),
796 _ => ::rustc_span::macros::bug_impl(None,
format_args!("debuginfo::build_basic_type_di_node - `t` is invalid type"),
Location::caller())bug!("debuginfo::build_basic_type_di_node - `t` is invalid type"),
797 };
798
799 let mut needs_typedef = cpp_like_debuginfo;
811
812 let ty_di_node = match t.kind() {
813 ty::Uint(UintTy::Usize) => {
814 needs_typedef = true;
815
816 let equivalent = match t.primitive_size(cx.tcx).bits() {
817 8 => cx.tcx.types.u8,
818 16 => cx.tcx.types.u16,
819 32 => cx.tcx.types.u32,
820 64 => cx.tcx.types.u64,
821 128 => cx.tcx.types.u128,
822 x => ::rustc_span::macros::bug_impl(None,
format_args!("Unexpected signed int size {0}", x), Location::caller())bug!("Unexpected signed int size {x}"),
823 };
824 type_di_node(cx, equivalent)
825 }
826 ty::Int(IntTy::Isize) => {
827 needs_typedef = true;
828
829 let equivalent = match t.primitive_size(cx.tcx).bits() {
830 8 => cx.tcx.types.i8,
831 16 => cx.tcx.types.i16,
832 32 => cx.tcx.types.i32,
833 64 => cx.tcx.types.i64,
834 128 => cx.tcx.types.i128,
835 x => ::rustc_span::macros::bug_impl(None,
format_args!("Unexpected signed int size: {0}", x), Location::caller())bug!("Unexpected signed int size: {x}"),
836 };
837 type_di_node(cx, equivalent)
838 }
839 _ => create_basic_type(cx, name, cx.size_of(t), encoding),
840 };
841
842 if !needs_typedef {
843 return DINodeCreationResult::new(ty_di_node, false);
844 }
845
846 let typedef_name = match t.kind() {
847 ty::Int(int_ty) => int_ty.name_str(),
848 ty::Uint(uint_ty) => uint_ty.name_str(),
849 ty::Float(float_ty) => float_ty.name_str(),
850 _ => return DINodeCreationResult::new(ty_di_node, false),
851 };
852
853 let typedef_di_node = unsafe {
854 llvm::LLVMDIBuilderCreateTypedef(
855 DIB(cx),
856 ty_di_node,
857 typedef_name.as_ptr(),
858 typedef_name.len(),
859 unknown_file_metadata(cx),
860 0, None, 0u32, )
864 };
865
866 DINodeCreationResult::new(typedef_di_node, false)
867}
868
869fn create_basic_type<'ll, 'tcx>(
870 cx: &CodegenCx<'ll, 'tcx>,
871 name: &str,
872 size: Size,
873 encoding: u32,
874) -> &'ll DIBasicType {
875 unsafe {
876 llvm::LLVMDIBuilderCreateBasicType(
877 DIB(cx),
878 name.as_ptr(),
879 name.len(),
880 size.bits(),
881 encoding,
882 DIFlags::FlagZero,
883 )
884 }
885}
886
887fn build_foreign_type_di_node<'ll, 'tcx>(
888 cx: &CodegenCx<'ll, 'tcx>,
889 t: Ty<'tcx>,
890 unique_type_id: UniqueTypeId<'tcx>,
891) -> DINodeCreationResult<'ll> {
892 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:892",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(892u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&["message"],
::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("build_foreign_type_di_node: {0:?}",
t) as &dyn ::tracing::field::Value))])
});
} else { ; }
};debug!("build_foreign_type_di_node: {:?}", t);
893
894 let &ty::Foreign(def_id) = unique_type_id.expect_ty().kind() else {
895 ::rustc_span::macros::bug_impl(None,
format_args!("build_foreign_type_di_node() called with unexpected type: {0:?}",
unique_type_id.expect_ty()), Location::caller());bug!(
896 "build_foreign_type_di_node() called with unexpected type: {:?}",
897 unique_type_id.expect_ty()
898 );
899 };
900
901 build_type_with_children(
902 cx,
903 type_map::stub(
904 cx,
905 Stub::Struct,
906 unique_type_id,
907 &compute_debuginfo_type_name(cx.tcx, t, false),
908 None,
909 cx.size_and_align_of(t),
910 Some(get_namespace_for_item(cx, def_id)),
911 DIFlags::FlagZero,
912 ),
913 |_, _| ::smallvec::SmallVec::new()smallvec![],
914 NO_GENERICS,
915 )
916}
917
918pub(crate) fn build_compile_unit_di_node<'ll, 'tcx>(
919 tcx: TyCtxt<'tcx>,
920 codegen_unit_name: &str,
921 debug_context: &CodegenUnitDebugContext<'ll, 'tcx>,
922) -> &'ll DIDescriptor {
923 let mut name_in_debuginfo = tcx
924 .sess
925 .local_crate_source_file()
926 .map(|src| src.path(RemapPathScopeComponents::DEBUGINFO).to_path_buf())
927 .unwrap_or_else(|| PathBuf::from(tcx.crate_name(LOCAL_CRATE).as_str()));
928
929 name_in_debuginfo.push("@");
947 name_in_debuginfo.push(codegen_unit_name);
948
949 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs:949",
"rustc_codegen_llvm::debuginfo::metadata",
::tracing::Level::DEBUG,
::tracing_core::__macro_support::Option::Some("/rustc-dev/bdf712ee87c22a2b5c60db2e1af8a63e3cfd1a2e/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs"),
::tracing_core::__macro_support::Option::Some(949u32),
::tracing_core::__macro_support::Option::Some("rustc_codegen_llvm::debuginfo::metadata"),
::tracing_core::field::FieldSet::new(&["message"],
::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::DEBUG <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("build_compile_unit_di_node: {0:?}",
name_in_debuginfo) as &dyn ::tracing::field::Value))])
});
} else { ; }
};debug!("build_compile_unit_di_node: {:?}", name_in_debuginfo);
950 let rustc_producer = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("rustc version {0}",
tcx.sess.cfg_version))
})format!("rustc version {}", tcx.sess.cfg_version);
951 let producer = ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("clang LLVM ({0})", rustc_producer))
})format!("clang LLVM ({rustc_producer})");
953
954 let name_in_debuginfo = name_in_debuginfo.to_string_lossy();
955 let work_dir = tcx.sess.psess.source_map().working_dir();
956 let output_filenames = tcx.output_filenames(());
957 let split_name = if tcx.sess.target_can_use_split_dwarf()
958 && let Some(f) = output_filenames.split_dwarf_path(
959 tcx.sess.split_debuginfo(),
960 tcx.sess.opts.unstable_opts.split_dwarf_kind,
961 codegen_unit_name,
962 ) {
963 Some(tcx.sess.source_map().path_mapping().to_real_filename(work_dir, f))
965 } else {
966 None
967 };
968 let split_name = split_name
969 .as_ref()
970 .map(|f| f.path(RemapPathScopeComponents::DEBUGINFO).to_string_lossy())
971 .unwrap_or_default();
972 let work_dir = work_dir.path(RemapPathScopeComponents::DEBUGINFO).to_string_lossy();
973 let kind = DebugEmissionKind::from_generic(tcx.sess.opts.debuginfo);
974
975 let dwarf_version = tcx.sess.dwarf_version();
976 let is_dwarf_kind =
977 #[allow(non_exhaustive_omitted_patterns)] match tcx.sess.target.debuginfo_kind
{
DebuginfoKind::Dwarf | DebuginfoKind::DwarfDsym => true,
_ => false,
}matches!(tcx.sess.target.debuginfo_kind, DebuginfoKind::Dwarf | DebuginfoKind::DwarfDsym);
978 let debug_name_table_kind = if is_dwarf_kind && dwarf_version <= 4 {
980 DebugNameTableKind::None
981 } else {
982 DebugNameTableKind::Default
983 };
984
985 unsafe {
986 let compile_unit_file = create_file(
987 debug_context.builder.as_ref(),
988 &name_in_debuginfo,
989 &work_dir,
990 "",
991 llvm::ChecksumKind::None,
992 None,
993 );
994 let flags = c"";
995
996 llvm::LLVMRustDIBuilderCreateCompileUnit(
997 debug_context.builder.as_ref(),
998 dwarf_const::DW_LANG_Rust,
999 compile_unit_file,
1000 producer.as_ptr(),
1001 producer.len(),
1002 tcx.sess.opts.optimize != config::OptLevel::No,
1003 flags.as_ptr(),
1004 0,
1005 split_name.as_ptr(),
1009 split_name.len(),
1010 kind,
1011 0,
1012 tcx.sess.opts.unstable_opts.split_dwarf_inlining,
1013 tcx.sess.opts.unstable_opts.debuginfo_for_profiling,
1014 debug_name_table_kind,
1015 )
1016 }
1017}
1018
1019fn build_field_di_node<'ll, 'tcx>(
1021 cx: &CodegenCx<'ll, 'tcx>,
1022 owner: &'ll DIScope,
1023 name: &str,
1024 layout: TyAndLayout<'tcx>,
1025 offset: Size,
1026 flags: DIFlags,
1027 type_di_node: &'ll DIType,
1028 def_id: Option<DefId>,
1029) -> &'ll DIType {
1030 let (file_metadata, line_number) = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers
1031 {
1032 file_metadata_from_def_id(cx, def_id)
1033 } else {
1034 (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
1035 };
1036 create_member_type(
1037 cx,
1038 owner,
1039 name,
1040 file_metadata,
1041 line_number,
1042 layout,
1043 offset,
1044 flags,
1045 type_di_node,
1046 )
1047}
1048
1049fn create_member_type<'ll, 'tcx>(
1050 cx: &CodegenCx<'ll, 'tcx>,
1051 owner: &'ll DIScope,
1052 name: &str,
1053 file_metadata: &'ll DIType,
1054 line_number: u32,
1055 layout: TyAndLayout<'tcx>,
1056 offset: Size,
1057 flags: DIFlags,
1058 type_di_node: &'ll DIType,
1059) -> &'ll DIType {
1060 unsafe {
1061 llvm::LLVMDIBuilderCreateMemberType(
1062 DIB(cx),
1063 owner,
1064 name.as_ptr(),
1065 name.len(),
1066 file_metadata,
1067 line_number,
1068 layout.size.bits(),
1069 layout.align.bits() as u32,
1070 offset.bits(),
1071 flags,
1072 type_di_node,
1073 )
1074 }
1075}
1076
1077fn visibility_di_flags<'ll, 'tcx>(
1083 cx: &CodegenCx<'ll, 'tcx>,
1084 did: DefId,
1085 type_did: DefId,
1086) -> DIFlags {
1087 let parent_did = cx.tcx.parent(type_did);
1088 let visibility = cx.tcx.visibility(did);
1089 match visibility {
1090 Visibility::Public => DIFlags::FlagPublic,
1091 Visibility::Restricted(did) if did.to_def_id() == parent_did => DIFlags::FlagPrivate,
1093 Visibility::Restricted(..) => DIFlags::FlagProtected,
1095 }
1096}
1097
1098fn build_struct_type_di_node<'ll, 'tcx>(
1100 cx: &CodegenCx<'ll, 'tcx>,
1101 unique_type_id: UniqueTypeId<'tcx>,
1102 span: Span,
1103) -> DINodeCreationResult<'ll> {
1104 let struct_type = unique_type_id.expect_ty();
1105
1106 let ty::Adt(adt_def, _) = struct_type.kind() else {
1107 ::rustc_span::macros::bug_impl(None,
format_args!("build_struct_type_di_node() called with non-struct-type: {0:?}",
struct_type), Location::caller());bug!("build_struct_type_di_node() called with non-struct-type: {:?}", struct_type);
1108 };
1109 if !adt_def.is_struct() {
::core::panicking::panic("assertion failed: adt_def.is_struct()")
};assert!(adt_def.is_struct());
1110 let containing_scope = get_namespace_for_item(cx, adt_def.did());
1111 let struct_type_and_layout = cx.spanned_layout_of(struct_type, span);
1112 let variant_def = adt_def.non_enum_variant();
1113 let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
1114 Some(file_metadata_from_def_id(cx, Some(adt_def.did())))
1115 } else {
1116 None
1117 };
1118 let name = compute_debuginfo_type_name(cx.tcx, struct_type, false);
1119
1120 if struct_type.is_scalable_vector() {
1121 let parts = struct_type.scalable_vector_parts(cx.tcx).unwrap();
1122 return build_scalable_vector_di_node(
1123 cx,
1124 unique_type_id,
1125 name,
1126 *adt_def,
1127 parts,
1128 struct_type_and_layout.layout,
1129 def_location,
1130 containing_scope,
1131 );
1132 }
1133
1134 type_map::build_type_with_children(
1135 cx,
1136 type_map::stub(
1137 cx,
1138 Stub::Struct,
1139 unique_type_id,
1140 &name,
1141 def_location,
1142 size_and_align_of(struct_type_and_layout),
1143 Some(containing_scope),
1144 visibility_di_flags(cx, adt_def.did(), adt_def.did()),
1145 ),
1146 |cx, owner| {
1148 variant_def
1149 .fields
1150 .iter()
1151 .enumerate()
1152 .map(|(i, f)| {
1153 let field_name = if variant_def.ctor_kind() == Some(CtorKind::Fn) {
1154 tuple_field_name(i)
1156 } else {
1157 Cow::Borrowed(f.name.as_str())
1159 };
1160 let field_layout = struct_type_and_layout.field(cx, i);
1161 let def_id = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
1162 Some(f.did)
1163 } else {
1164 None
1165 };
1166 build_field_di_node(
1167 cx,
1168 owner,
1169 &field_name[..],
1170 field_layout,
1171 struct_type_and_layout.fields.offset(i),
1172 visibility_di_flags(cx, f.did, adt_def.did()),
1173 type_di_node(cx, field_layout.ty),
1174 def_id,
1175 )
1176 })
1177 .collect()
1178 },
1179 |cx| build_generic_type_param_di_nodes(cx, struct_type),
1180 )
1181}
1182
1183fn build_scalable_vector_di_node<'ll, 'tcx>(
1201 cx: &CodegenCx<'ll, 'tcx>,
1202 unique_type_id: UniqueTypeId<'tcx>,
1203 name: String,
1204 adt_def: AdtDef<'tcx>,
1205 (element_count, element_ty, number_of_vectors): (u16, Ty<'tcx>, NumScalableVectors),
1206 layout: Layout<'tcx>,
1207 def_location: Option<DefinitionLocation<'ll>>,
1208 containing_scope: &'ll DIScope,
1209) -> DINodeCreationResult<'ll> {
1210 use dwarf_const::{DW_OP_bregx, DW_OP_constu, DW_OP_minus, DW_OP_mul};
1211 if !adt_def.repr().scalable() {
::core::panicking::panic("assertion failed: adt_def.repr().scalable()")
};assert!(adt_def.repr().scalable());
1212 {
match cx.tcx.sess.target.arch {
Arch::AArch64 => {}
ref left_val => {
::core::panicking::assert_matches_failed(left_val,
"Arch::AArch64", ::core::option::Option::None);
}
}
};assert_matches!(cx.tcx.sess.target.arch, Arch::AArch64);
1215
1216 let (file_metadata, line_number) = if let Some(def_location) = def_location {
1217 (def_location.0, def_location.1)
1218 } else {
1219 (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
1220 };
1221
1222 let (bitstride, element_di_node) = if element_ty.is_bool() {
1223 (Some(llvm::LLVMValueAsMetadata(cx.const_i64(1))), type_di_node(cx, cx.tcx.types.u8))
1224 } else {
1225 (None, type_di_node(cx, element_ty))
1226 };
1227
1228 let number_of_elements: u64 = (element_count as u64) * (number_of_vectors.0 as u64);
1229 let number_of_elements_per_vg = number_of_elements / 2;
1230 let mut expr = smallvec::SmallVec::<[u64; 9]>::new();
1231 expr.push(DW_OP_constu); expr.push(number_of_elements_per_vg);
1234 expr.push(DW_OP_bregx); expr.push(46u64);
1236 expr.push(0u64);
1237 expr.push(DW_OP_mul); expr.push(DW_OP_constu); expr.push(1u64);
1240 expr.push(DW_OP_minus); let di_builder = DIB(cx);
1243 let metadata = unsafe {
1244 let upper = llvm::LLVMDIBuilderCreateExpression(di_builder, expr.as_ptr(), expr.len());
1245 let subrange = llvm::LLVMRustDIGetOrCreateSubrange(
1246 di_builder,
1247 None,
1248 llvm::LLVMValueAsMetadata(cx.const_i64(0)),
1249 upper,
1250 None,
1251 );
1252 let subscripts = create_DIArray(di_builder, &[Some(subrange)]);
1253 let vector_ty = llvm::LLVMRustDICreateVectorType(
1254 di_builder,
1255 0,
1256 layout.align.bits() as u32,
1257 element_di_node,
1258 subscripts,
1259 bitstride,
1260 );
1261 llvm::LLVMDIBuilderCreateTypedef(
1262 di_builder,
1263 vector_ty,
1264 name.as_ptr(),
1265 name.len(),
1266 file_metadata,
1267 line_number,
1268 Some(containing_scope),
1269 layout.align.bits() as u32,
1270 )
1271 };
1272
1273 debug_context(cx).type_map.insert(unique_type_id, metadata);
1274 DINodeCreationResult { di_node: metadata, already_stored_in_typemap: true }
1275}
1276
1277fn build_upvar_field_di_nodes<'ll, 'tcx>(
1284 cx: &CodegenCx<'ll, 'tcx>,
1285 closure_or_coroutine_ty: Ty<'tcx>,
1286 closure_or_coroutine_di_node: &'ll DIType,
1287) -> SmallVec<&'ll DIType> {
1288 let (&def_id, up_var_tys) = match closure_or_coroutine_ty.kind() {
1289 ty::Coroutine(def_id, args) => (def_id, args.as_coroutine().upvar_tys()),
1290 ty::Closure(def_id, args) => (def_id, args.as_closure().upvar_tys()),
1291 ty::CoroutineClosure(def_id, args) => (def_id, args.as_coroutine_closure().upvar_tys()),
1292 _ => {
1293 ::rustc_span::macros::bug_impl(None,
format_args!("build_upvar_field_di_nodes() called with non-closure-or-coroutine-type: {0:?}",
closure_or_coroutine_ty), Location::caller())bug!(
1294 "build_upvar_field_di_nodes() called with non-closure-or-coroutine-type: {:?}",
1295 closure_or_coroutine_ty
1296 )
1297 }
1298 };
1299
1300 for ty in up_var_tys.iter() {
1301 cx.tcx.assert_fully_normalized(cx.typing_env(), ty);
1302 }
1303
1304 let capture_names = cx.tcx.closure_saved_names_of_captured_variables(def_id);
1305 let layout = cx.layout_of(closure_or_coroutine_ty);
1306
1307 up_var_tys
1308 .into_iter()
1309 .zip(capture_names.iter())
1310 .enumerate()
1311 .map(|(index, (up_var_ty, capture_name))| {
1312 build_field_di_node(
1313 cx,
1314 closure_or_coroutine_di_node,
1315 capture_name.as_str(),
1316 cx.layout_of(up_var_ty),
1317 layout.fields.offset(index),
1318 DIFlags::FlagZero,
1319 type_di_node(cx, up_var_ty),
1320 None,
1321 )
1322 })
1323 .collect()
1324}
1325
1326fn build_tuple_type_di_node<'ll, 'tcx>(
1328 cx: &CodegenCx<'ll, 'tcx>,
1329 unique_type_id: UniqueTypeId<'tcx>,
1330) -> DINodeCreationResult<'ll> {
1331 let tuple_type = unique_type_id.expect_ty();
1332 let &ty::Tuple(component_types) = tuple_type.kind() else {
1333 ::rustc_span::macros::bug_impl(None,
format_args!("build_tuple_type_di_node() called with non-tuple-type: {0:?}",
tuple_type), Location::caller())bug!("build_tuple_type_di_node() called with non-tuple-type: {:?}", tuple_type)
1334 };
1335
1336 let tuple_type_and_layout = cx.layout_of(tuple_type);
1337 let type_name = compute_debuginfo_type_name(cx.tcx, tuple_type, false);
1338
1339 type_map::build_type_with_children(
1340 cx,
1341 type_map::stub(
1342 cx,
1343 Stub::Struct,
1344 unique_type_id,
1345 &type_name,
1346 None,
1347 size_and_align_of(tuple_type_and_layout),
1348 NO_SCOPE_METADATA,
1349 DIFlags::FlagZero,
1350 ),
1351 |cx, tuple_di_node| {
1353 component_types
1354 .into_iter()
1355 .enumerate()
1356 .map(|(index, component_type)| {
1357 build_field_di_node(
1358 cx,
1359 tuple_di_node,
1360 &tuple_field_name(index),
1361 cx.layout_of(component_type),
1362 tuple_type_and_layout.fields.offset(index),
1363 DIFlags::FlagZero,
1364 type_di_node(cx, component_type),
1365 None,
1366 )
1367 })
1368 .collect()
1369 },
1370 NO_GENERICS,
1371 )
1372}
1373
1374fn build_closure_env_di_node<'ll, 'tcx>(
1376 cx: &CodegenCx<'ll, 'tcx>,
1377 unique_type_id: UniqueTypeId<'tcx>,
1378) -> DINodeCreationResult<'ll> {
1379 let closure_env_type = unique_type_id.expect_ty();
1380 let &(ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _)) = closure_env_type.kind()
1381 else {
1382 ::rustc_span::macros::bug_impl(None,
format_args!("build_closure_env_di_node() called with non-closure-type: {0:?}",
closure_env_type), Location::caller())bug!("build_closure_env_di_node() called with non-closure-type: {:?}", closure_env_type)
1383 };
1384 let containing_scope = get_namespace_for_item(cx, def_id);
1385 let type_name = compute_debuginfo_type_name(cx.tcx, closure_env_type, false);
1386
1387 let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
1388 Some(file_metadata_from_def_id(cx, Some(def_id)))
1389 } else {
1390 None
1391 };
1392
1393 type_map::build_type_with_children(
1394 cx,
1395 type_map::stub(
1396 cx,
1397 Stub::Struct,
1398 unique_type_id,
1399 &type_name,
1400 def_location,
1401 cx.size_and_align_of(closure_env_type),
1402 Some(containing_scope),
1403 DIFlags::FlagZero,
1404 ),
1405 |cx, owner| build_upvar_field_di_nodes(cx, closure_env_type, owner),
1407 NO_GENERICS,
1408 )
1409}
1410
1411fn build_union_type_di_node<'ll, 'tcx>(
1413 cx: &CodegenCx<'ll, 'tcx>,
1414 unique_type_id: UniqueTypeId<'tcx>,
1415 span: Span,
1416) -> DINodeCreationResult<'ll> {
1417 let union_type = unique_type_id.expect_ty();
1418 let (union_def_id, variant_def) = match union_type.kind() {
1419 ty::Adt(def, _) => (def.did(), def.non_enum_variant()),
1420 _ => ::rustc_span::macros::bug_impl(None,
format_args!("build_union_type_di_node on a non-ADT"), Location::caller())bug!("build_union_type_di_node on a non-ADT"),
1421 };
1422 let containing_scope = get_namespace_for_item(cx, union_def_id);
1423 let union_ty_and_layout = cx.spanned_layout_of(union_type, span);
1424 let type_name = compute_debuginfo_type_name(cx.tcx, union_type, false);
1425 let def_location = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
1426 Some(file_metadata_from_def_id(cx, Some(union_def_id)))
1427 } else {
1428 None
1429 };
1430
1431 type_map::build_type_with_children(
1432 cx,
1433 type_map::stub(
1434 cx,
1435 Stub::Union,
1436 unique_type_id,
1437 &type_name,
1438 def_location,
1439 size_and_align_of(union_ty_and_layout),
1440 Some(containing_scope),
1441 DIFlags::FlagZero,
1442 ),
1443 |cx, owner| {
1445 variant_def
1446 .fields
1447 .iter()
1448 .enumerate()
1449 .map(|(i, f)| {
1450 let field_layout = union_ty_and_layout.field(cx, i);
1451 let def_id = if cx.sess().opts.unstable_opts.debug_info_type_line_numbers {
1452 Some(f.did)
1453 } else {
1454 None
1455 };
1456 build_field_di_node(
1457 cx,
1458 owner,
1459 f.name.as_str(),
1460 field_layout,
1461 Size::ZERO,
1462 DIFlags::FlagZero,
1463 type_di_node(cx, field_layout.ty),
1464 def_id,
1465 )
1466 })
1467 .collect()
1468 },
1469 |cx| build_generic_type_param_di_nodes(cx, union_type),
1471 )
1472}
1473
1474fn build_generic_type_param_di_nodes<'ll, 'tcx>(
1476 cx: &CodegenCx<'ll, 'tcx>,
1477 ty: Ty<'tcx>,
1478) -> SmallVec<Option<&'ll DIType>> {
1479 if let ty::Adt(def, args) = *ty.kind() {
1480 if args.types().next().is_some() {
1482 let generics = cx.tcx.generics_of(def.did());
1483 let names = get_parameter_names(cx, generics);
1484 let template_params: SmallVec<_> = iter::zip(args, names)
1485 .filter_map(|(kind, name)| {
1486 kind.as_type().map(|ty| {
1487 let actual_type = cx
1488 .tcx
1489 .normalize_erasing_regions(cx.typing_env(), Unnormalized::new_wip(ty));
1490 let actual_type_di_node = type_di_node(cx, actual_type);
1491 Some(cx.create_template_type_parameter(name.as_str(), actual_type_di_node))
1492 })
1493 })
1494 .collect();
1495
1496 return template_params;
1497 }
1498 }
1499
1500 return ::smallvec::SmallVec::new()smallvec![];
1501
1502 fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
1503 let mut names = generics
1504 .parent
1505 .map_or_else(Vec::new, |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id)));
1506 names.extend(generics.own_params.iter().map(|param| param.name));
1507 names
1508 }
1509}
1510
1511pub(crate) fn build_global_var_di_node<'ll>(
1515 cx: &CodegenCx<'ll, '_>,
1516 def_id: DefId,
1517 global: Value<'ll>,
1518) {
1519 if cx.dbg_cx.is_none() {
1520 return;
1521 }
1522
1523 if cx.sess().opts.debuginfo != DebugInfo::Full {
1525 return;
1526 }
1527
1528 let tcx = cx.tcx;
1529
1530 let var_scope = get_namespace_for_item(cx, def_id);
1533 let (file_metadata, line_number) = file_metadata_from_def_id(cx, Some(def_id));
1534
1535 let is_local_to_unit = is_node_local_to_unit(cx, def_id);
1536
1537 let DefKind::Static { nested, .. } = cx.tcx.def_kind(def_id) else { ::rustc_span::macros::bug_impl(None, format_args!("impossible case reached"),
Location::caller())bug!() };
1538 if nested {
1539 return;
1540 }
1541 let variable_type = Instance::mono(cx.tcx, def_id).ty(cx.tcx, cx.typing_env());
1542 let type_di_node = type_di_node(cx, variable_type);
1543 let var_name = tcx.item_name(def_id);
1544 let var_name = var_name.as_str();
1545 let linkage_name = mangled_name_of_instance(cx, Instance::mono(tcx, def_id)).name;
1546 let linkage_name = if var_name == linkage_name { "" } else { linkage_name };
1549
1550 let global_align = cx.align_of(variable_type);
1551
1552 DIB(cx).create_static_variable(
1553 Some(var_scope),
1554 var_name,
1555 linkage_name,
1556 file_metadata,
1557 line_number,
1558 type_di_node,
1559 is_local_to_unit,
1560 global, None, Some(global_align),
1563 );
1564}
1565
1566fn build_vtable_type_di_node<'ll, 'tcx>(
1576 cx: &CodegenCx<'ll, 'tcx>,
1577 ty: Ty<'tcx>,
1578 poly_trait_ref: Option<ty::ExistentialTraitRef<'tcx>>,
1579) -> &'ll DIType {
1580 let tcx = cx.tcx;
1581
1582 let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
1583 let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
1584 let trait_ref = tcx.erase_and_anonymize_regions(trait_ref);
1585
1586 tcx.vtable_entries(trait_ref)
1587 } else {
1588 TyCtxt::COMMON_VTABLE_ENTRIES
1589 };
1590
1591 let void_pointer_ty = Ty::new_imm_ptr(tcx, tcx.types.unit);
1594 let void_pointer_type_di_node = type_di_node(cx, void_pointer_ty);
1595 let usize_di_node = type_di_node(cx, tcx.types.usize);
1596 let pointer_layout = cx.layout_of(void_pointer_ty);
1597 let pointer_size = pointer_layout.size;
1598 let pointer_align = pointer_layout.align;
1599 {
match (&cx.size_and_align_of(tcx.types.usize),
&(pointer_size, pointer_align)) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(cx.size_and_align_of(tcx.types.usize), (pointer_size, pointer_align));
1603
1604 let vtable_type_name =
1605 compute_debuginfo_vtable_name(cx.tcx, ty, poly_trait_ref, VTableNameKind::Type);
1606 let unique_type_id = UniqueTypeId::for_vtable_ty(tcx, ty, poly_trait_ref);
1607 let size = pointer_size * vtable_entries.len() as u64;
1608
1609 let vtable_holder = type_di_node(cx, ty);
1612
1613 build_type_with_children(
1614 cx,
1615 type_map::stub(
1616 cx,
1617 Stub::VTableTy { vtable_holder },
1618 unique_type_id,
1619 &vtable_type_name,
1620 None,
1621 (size, pointer_align),
1622 NO_SCOPE_METADATA,
1623 DIFlags::FlagArtificial,
1624 ),
1625 |cx, vtable_type_di_node| {
1626 vtable_entries
1627 .iter()
1628 .enumerate()
1629 .filter_map(|(index, vtable_entry)| {
1630 let (field_name, field_type_di_node) = match vtable_entry {
1631 ty::VtblEntry::MetadataDropInPlace => {
1632 ("drop_in_place".to_string(), void_pointer_type_di_node)
1633 }
1634 ty::VtblEntry::Method(_) => {
1635 (::alloc::__export::must_use({
::alloc::fmt::format(format_args!("__method{0}", index))
})format!("__method{index}"), void_pointer_type_di_node)
1639 }
1640 ty::VtblEntry::TraitVPtr(_) => {
1641 (::alloc::__export::must_use({
::alloc::fmt::format(format_args!("__super_trait_ptr{0}", index))
})format!("__super_trait_ptr{index}"), void_pointer_type_di_node)
1642 }
1643 ty::VtblEntry::MetadataAlign => ("align".to_string(), usize_di_node),
1644 ty::VtblEntry::MetadataSize => ("size".to_string(), usize_di_node),
1645 ty::VtblEntry::Vacant => return None,
1646 };
1647
1648 let field_offset = pointer_size * index as u64;
1649
1650 Some(build_field_di_node(
1651 cx,
1652 vtable_type_di_node,
1653 &field_name,
1654 pointer_layout,
1655 field_offset,
1656 DIFlags::FlagZero,
1657 field_type_di_node,
1658 None,
1659 ))
1660 })
1661 .collect()
1662 },
1663 NO_GENERICS,
1664 )
1665 .di_node
1666}
1667
1668fn build_unsafe_binder_type_di_node<'ll, 'tcx>(
1675 cx: &CodegenCx<'ll, 'tcx>,
1676 binder_type: Ty<'tcx>,
1677 unique_type_id: UniqueTypeId<'tcx>,
1678) -> DINodeCreationResult<'ll> {
1679 let ty::UnsafeBinder(inner) = binder_type.kind() else {
1680 ::rustc_span::macros::bug_impl(None,
format_args!("Only ty::UnsafeBinder is valid for build_unsafe_binder_type_di_node. Found {0:?} instead.",
binder_type), Location::caller())bug!(
1681 "Only ty::UnsafeBinder is valid for build_unsafe_binder_type_di_node. Found {:?} instead.",
1682 binder_type
1683 )
1684 };
1685 let inner_type = cx.tcx.instantiate_bound_regions_with_erased((*inner).into());
1686 let inner_type_di_node = type_di_node(cx, inner_type);
1687
1688 let type_name = compute_debuginfo_type_name(cx.tcx, binder_type, true);
1689 type_map::build_type_with_children(
1690 cx,
1691 type_map::stub(
1692 cx,
1693 Stub::Struct,
1694 unique_type_id,
1695 &type_name,
1696 None,
1697 cx.size_and_align_of(binder_type),
1698 NO_SCOPE_METADATA,
1699 DIFlags::FlagZero,
1700 ),
1701 |cx, unsafe_binder_type_di_node| {
1702 let inner_layout = cx.layout_of(inner_type);
1703 {
let count = 0usize + 1usize;
let mut vec = ::smallvec::SmallVec::new();
if count <= vec.inline_size() {
vec.push(build_field_di_node(cx, unsafe_binder_type_di_node, "inner",
inner_layout, Size::ZERO, DIFlags::FlagZero,
inner_type_di_node, None));
vec
} else {
::smallvec::SmallVec::from_vec(::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
[build_field_di_node(cx, unsafe_binder_type_di_node,
"inner", inner_layout, Size::ZERO, DIFlags::FlagZero,
inner_type_di_node, None)])))
}
}smallvec![build_field_di_node(
1704 cx,
1705 unsafe_binder_type_di_node,
1706 "inner",
1707 inner_layout,
1708 Size::ZERO,
1709 DIFlags::FlagZero,
1710 inner_type_di_node,
1711 None,
1712 )]
1713 },
1714 NO_GENERICS,
1715 )
1716}
1717
1718fn find_vtable_behind_cast<'ll>(vtable: Value<'ll>) -> Value<'ll> {
1727 unsafe {
1729 if let Some(c) = llvm::LLVMIsAConstantExpr(vtable) {
1730 if llvm::LLVMGetConstOpcode(c) == llvm::Opcode::AddrSpaceCast {
1731 return llvm::LLVMGetOperand(c, 0).unwrap();
1732 }
1733 }
1734 }
1735 vtable
1736}
1737
1738#[derive(#[automatically_derived]impl ::core::marker::StructuralPartialEq for
VCallVisibility {
}
#[automatically_derived]impl ::core::cmp::PartialEq for VCallVisibility {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for VCallVisibility { }Eq, #[automatically_derived]impl ::core::cmp::PartialOrd for VCallVisibility {
#[inline]
fn partial_cmp(&self, other: &Self)
-> ::core::option::Option<::core::cmp::Ordering> {
::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
}
}PartialOrd, #[automatically_derived]impl ::core::cmp::Ord for VCallVisibility {
#[inline]
fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
&::core::intrinsics::discriminant_value(other))
}
}Ord)]
1742enum VCallVisibility {
1743 Public = 0,
1745 LinkageUnit = 1,
1748 TranslationUnit = 2,
1750}
1751
1752impl VCallVisibility {
1753 fn for_trait<'ll, 'tcx>(
1754 cx: &CodegenCx<'ll, 'tcx>,
1755 trait_ref: &ExistentialTraitRef<'tcx>,
1756 ) -> Self {
1757 let lto = cx.sess().lto();
1758 let trait_vis = cx.tcx.visibility(trait_ref.def_id);
1759 let cgus = cx.sess().codegen_units().as_usize();
1760 let single_cgu = cgus == 1;
1761
1762 match (lto, trait_vis, single_cgu) {
1765 (Lto::No | Lto::ThinLocal, Visibility::Public, _)
1768 | (Lto::No, Visibility::Restricted(_), false) => VCallVisibility::Public,
1769 (Lto::Fat | Lto::Thin, Visibility::Public, _)
1774 | (Lto::ThinLocal | Lto::Thin | Lto::Fat, Visibility::Restricted(_), false) => {
1775 VCallVisibility::LinkageUnit
1776 }
1777 (_, Visibility::Restricted(_), true) => VCallVisibility::TranslationUnit,
1780 }
1781 }
1782}
1783
1784pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
1789 cx: &CodegenCx<'ll, 'tcx>,
1790 trait_hierarchy: &[ExistentialTraitRef<'tcx>],
1791 vtable: Value<'ll>,
1792) {
1793 if !cx.sess().opts.unstable_opts.virtual_function_elimination || cx.sess().lto() != Lto::Fat {
1796 return;
1797 }
1798
1799 let Some(vcall_visibility) =
1801 trait_hierarchy.iter().map(|trait_ref| VCallVisibility::for_trait(cx, trait_ref)).min()
1802 else {
1803 return;
1804 };
1805
1806 let vtable = find_vtable_behind_cast(vtable);
1808
1809 let vtable_offset = 0;
1811
1812 for trait_ref in trait_hierarchy {
1814 let trait_ref_typeid = typeid_for_trait_ref(cx.tcx, *trait_ref);
1815 let typeid = cx.create_metadata(trait_ref_typeid.as_bytes());
1816
1817 let type_ = [llvm::LLVMValueAsMetadata(cx.const_u64(vtable_offset)), typeid];
1818 cx.global_add_metadata_node(vtable, llvm::MD_type, &type_);
1819 }
1820
1821 let vcall_visibility = [llvm::LLVMValueAsMetadata(cx.const_u64(vcall_visibility as u64))];
1823 cx.global_set_metadata_node(vtable, llvm::MD_vcall_visibility, &vcall_visibility);
1824}
1825
1826pub(crate) fn create_vtable_di_node<'ll, 'tcx>(
1831 cx: &CodegenCx<'ll, 'tcx>,
1832 ty: Ty<'tcx>,
1833 poly_trait_ref: Option<ty::ExistentialTraitRef<'tcx>>,
1834 vtable: Value<'ll>,
1835) {
1836 if cx.dbg_cx.is_none() {
1837 return;
1838 }
1839
1840 if cx.sess().opts.debuginfo != DebugInfo::Full {
1842 return;
1843 }
1844
1845 let vtable = find_vtable_behind_cast(vtable);
1847
1848 llvm::set_unnamed_address(vtable, llvm::UnnamedAddr::No);
1852
1853 let vtable_name =
1854 compute_debuginfo_vtable_name(cx.tcx, ty, poly_trait_ref, VTableNameKind::GlobalVariable);
1855 let vtable_type_di_node = build_vtable_type_di_node(cx, ty, poly_trait_ref);
1856
1857 DIB(cx).create_static_variable(
1858 NO_SCOPE_METADATA,
1859 &vtable_name,
1860 "", unknown_file_metadata(cx),
1862 UNKNOWN_LINE_NUMBER,
1863 vtable_type_di_node,
1864 true, vtable, None, None::<Align>,
1868 );
1869}
1870
1871pub(crate) fn extend_scope_to_file<'ll>(
1873 cx: &CodegenCx<'ll, '_>,
1874 scope_metadata: &'ll DIScope,
1875 file: &SourceFile,
1876) -> &'ll DILexicalBlock {
1877 let file_metadata = file_metadata(cx, file);
1878 unsafe {
1879 llvm::LLVMDIBuilderCreateLexicalBlockFile(
1880 DIB(cx),
1881 scope_metadata,
1882 file_metadata,
1883 0u32,
1884 )
1885 }
1886}
1887
1888fn tuple_field_name(field_index: usize) -> Cow<'static, str> {
1889 const TUPLE_FIELD_NAMES: [&str; 16] = [
1890 "__0", "__1", "__2", "__3", "__4", "__5", "__6", "__7", "__8", "__9", "__10", "__11",
1891 "__12", "__13", "__14", "__15",
1892 ];
1893 TUPLE_FIELD_NAMES
1894 .get(field_index)
1895 .map(|s| Cow::from(*s))
1896 .unwrap_or_else(|| Cow::from(::alloc::__export::must_use({
::alloc::fmt::format(format_args!("__{0}", field_index))
})format!("__{field_index}")))
1897}
1898
1899pub(crate) type DefinitionLocation<'ll> = (&'ll DIFile, c_uint);
1900
1901pub(crate) fn file_metadata_from_def_id<'ll>(
1902 cx: &CodegenCx<'ll, '_>,
1903 def_id: Option<DefId>,
1904) -> DefinitionLocation<'ll> {
1905 if let Some(def_id) = def_id
1906 && let span = hygiene::walk_chain_collapsed(cx.tcx.def_span(def_id), DUMMY_SP)
1907 && !span.is_dummy()
1908 {
1909 let loc = cx.lookup_debug_loc(span.lo());
1910 (file_metadata(cx, &loc.file), loc.line)
1911 } else {
1912 (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
1913 }
1914}