1use 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 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 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}