Skip to main content

rustc_codegen_llvm/llvm/
diagnostic.rs

1//! LLVM diagnostic reports.
2
3use libc::c_uint;
4use rustc_span::InnerSpan;
5
6pub(crate) use self::Diagnostic::*;
7use self::OptimizationDiagnosticKind::*;
8use super::{DiagnosticInfo, SMDiagnostic};
9use crate::llvm::Value;
10
11#[derive(#[automatically_derived]impl ::core::marker::Copy for
    OptimizationDiagnosticKind {
}Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for OptimizationDiagnosticKind {
}
#[automatically_derived]impl ::core::clone::Clone for
    OptimizationDiagnosticKind {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for OptimizationDiagnosticKind
    {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "OptimizationRemark OptimizationMissed OptimizationAnalysis OptimizationAnalysisFPCommute OptimizationAnalysisAliasing OptimizationFailure OptimizationRemarkOther",
            match self {
                OptimizationDiagnosticKind::OptimizationRemark => 0usize,
                OptimizationDiagnosticKind::OptimizationMissed => 19usize,
                OptimizationDiagnosticKind::OptimizationAnalysis => 38usize,
                OptimizationDiagnosticKind::OptimizationAnalysisFPCommute =>
                    59usize,
                OptimizationDiagnosticKind::OptimizationAnalysisAliasing =>
                    89usize,
                OptimizationDiagnosticKind::OptimizationFailure => 118usize,
                OptimizationDiagnosticKind::OptimizationRemarkOther =>
                    138usize,
            })
    }
}Debug)]
12pub(crate) enum OptimizationDiagnosticKind {
13    OptimizationRemark,
14    OptimizationMissed,
15    OptimizationAnalysis,
16    OptimizationAnalysisFPCommute,
17    OptimizationAnalysisAliasing,
18    OptimizationFailure,
19    OptimizationRemarkOther,
20}
21
22pub(crate) struct OptimizationDiagnostic<'ll> {
23    pub kind: OptimizationDiagnosticKind,
24    pub pass_name: String,
25    #[expect(dead_code)]
26    pub function: &'ll Value,
27    pub line: c_uint,
28    pub column: c_uint,
29    pub filename: String,
30    pub message: String,
31}
32
33impl<'ll> OptimizationDiagnostic<'ll> {
34    unsafe fn unpack(kind: OptimizationDiagnosticKind, di: &'ll DiagnosticInfo) -> Self {
35        let mut function = None;
36        let mut line = 0;
37        let mut column = 0;
38
39        let mut message = None;
40        let mut filename = None;
41        let pass_name = super::build_string(|pass_name| {
42            message = super::build_string(|message| {
43                filename = super::build_string(|filename| unsafe {
44                    super::LLVMRustUnpackOptimizationDiagnostic(
45                        di,
46                        pass_name,
47                        &mut function,
48                        &mut line,
49                        &mut column,
50                        filename,
51                        message,
52                    )
53                })
54                .ok()
55            })
56            .ok()
57        })
58        .ok();
59
60        let mut filename = filename.unwrap_or_default();
61        if filename.is_empty() {
62            filename.push_str("<unknown file>");
63        }
64
65        OptimizationDiagnostic {
66            kind,
67            pass_name: pass_name.expect("got a non-UTF8 pass name from LLVM"),
68            function: function.unwrap(),
69            line,
70            column,
71            filename,
72            message: message.expect("got a non-UTF8 OptimizationDiagnostic message from LLVM"),
73        }
74    }
75}
76
77pub(crate) struct SrcMgrDiagnostic {
78    pub message: String,
79    pub source: Option<(String, Vec<InnerSpan>)>,
80}
81
82impl SrcMgrDiagnostic {
83    pub(crate) unsafe fn unpack(diag: &SMDiagnostic) -> SrcMgrDiagnostic {
84        // Recover the post-substitution assembly code from LLVM for better
85        // diagnostics.
86        let mut have_source = false;
87        let mut buffer = String::new();
88        let mut loc = 0;
89        let mut ranges = [0; 8];
90        let mut num_ranges = ranges.len() / 2;
91        let message = super::build_string(|message| {
92            buffer = super::build_string(|buffer| unsafe {
93                have_source = super::LLVMRustUnpackSMDiagnostic(
94                    diag,
95                    message,
96                    buffer,
97                    &mut loc,
98                    ranges.as_mut_ptr(),
99                    &mut num_ranges,
100                );
101            })
102            .expect("non-UTF8 inline asm");
103        })
104        .expect("non-UTF8 SMDiagnostic");
105
106        SrcMgrDiagnostic {
107            message,
108            source: have_source.then(|| {
109                let mut spans = ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [InnerSpan::new(loc as usize, loc as usize)]))vec![InnerSpan::new(loc as usize, loc as usize)];
110                for i in 0..num_ranges {
111                    spans.push(InnerSpan::new(ranges[i * 2] as usize, ranges[i * 2 + 1] as usize));
112                }
113                (buffer, spans)
114            }),
115        }
116    }
117}
118
119#[derive(#[automatically_derived]impl ::core::clone::Clone for InlineAsmDiagnostic {
    #[inline]
    fn clone(&self) -> Self {
        InlineAsmDiagnostic {
            severity: ::core::clone::Clone::clone(&self.severity),
            cookie: ::core::clone::Clone::clone(&self.cookie),
            message: ::core::clone::Clone::clone(&self.message),
            source: ::core::clone::Clone::clone(&self.source),
        }
    }
}Clone)]
120pub(crate) struct InlineAsmDiagnostic {
121    pub severity: super::DiagnosticSeverity,
122    pub cookie: u64,
123    pub message: String,
124    pub source: Option<(String, Vec<InnerSpan>)>,
125}
126
127impl InlineAsmDiagnostic {
128    unsafe fn unpackInlineAsm(di: &DiagnosticInfo) -> Self {
129        let mut cookie = 0;
130        let mut message = None;
131
132        unsafe {
133            super::LLVMRustUnpackInlineAsmDiagnostic(di, &mut cookie, &mut message);
134        }
135
136        InlineAsmDiagnostic {
137            severity: di.severity(),
138            cookie,
139            message: super::twine_to_string(message.unwrap()),
140            source: None,
141        }
142    }
143
144    unsafe fn unpackSrcMgr(di: &DiagnosticInfo) -> Self {
145        let mut cookie = 0;
146        let smdiag =
147            unsafe { SrcMgrDiagnostic::unpack(super::LLVMRustGetSMDiagnostic(di, &mut cookie)) };
148        InlineAsmDiagnostic {
149            severity: di.severity(),
150            cookie,
151            message: smdiag.message,
152            source: smdiag.source,
153        }
154    }
155}
156
157pub(crate) enum Diagnostic<'ll> {
158    Optimization(OptimizationDiagnostic<'ll>),
159    InlineAsm(InlineAsmDiagnostic),
160    StackSize,
161
162    /// LLVM has other types that we do not distinguish here.
163    Other(&'ll DiagnosticInfo),
164}
165
166impl<'ll> Diagnostic<'ll> {
167    pub(crate) unsafe fn unpack(di: &'ll DiagnosticInfo) -> Self {
168        use super::DiagnosticKind as Dk;
169
170        unsafe {
171            let kind = super::LLVMRustGetDiagInfoKind(di);
172            match kind {
173                Dk::InlineAsm => InlineAsm(InlineAsmDiagnostic::unpackInlineAsm(di)),
174
175                Dk::OptimizationRemark => {
176                    Optimization(OptimizationDiagnostic::unpack(OptimizationRemark, di))
177                }
178                Dk::OptimizationRemarkOther => {
179                    Optimization(OptimizationDiagnostic::unpack(OptimizationRemarkOther, di))
180                }
181                Dk::OptimizationRemarkMissed => {
182                    Optimization(OptimizationDiagnostic::unpack(OptimizationMissed, di))
183                }
184
185                Dk::OptimizationRemarkAnalysis => {
186                    Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di))
187                }
188
189                Dk::OptimizationRemarkAnalysisFPCommute => {
190                    Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisFPCommute, di))
191                }
192
193                Dk::OptimizationRemarkAnalysisAliasing => {
194                    Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisAliasing, di))
195                }
196
197                Dk::OptimizationFailure => {
198                    Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di))
199                }
200
201                Dk::SrcMgr => InlineAsm(InlineAsmDiagnostic::unpackSrcMgr(di)),
202
203                Dk::StackSize => StackSize,
204
205                _ => Other(di),
206            }
207        }
208    }
209}
210
211impl DiagnosticInfo {
212    pub(crate) fn severity(&self) -> super::DiagnosticSeverity {
213        unsafe { super::LLVMGetDiagInfoSeverity(self) }
214    }
215}