1 //! LLVM diagnostic reports.
3 pub use self::Diagnostic::*;
4 pub use self::OptimizationDiagnosticKind::*;
6 use crate::value::Value;
9 use super::{DiagnosticInfo, Twine};
11 #[derive(Copy, Clone)]
12 pub enum OptimizationDiagnosticKind {
16 OptimizationAnalysisFPCommute,
17 OptimizationAnalysisAliasing,
19 OptimizationRemarkOther,
22 impl OptimizationDiagnosticKind {
23 pub fn describe(self) -> &'static str {
25 OptimizationRemark | OptimizationRemarkOther => "remark",
26 OptimizationMissed => "missed",
27 OptimizationAnalysis => "analysis",
28 OptimizationAnalysisFPCommute => "floating-point",
29 OptimizationAnalysisAliasing => "aliasing",
30 OptimizationFailure => "failure",
35 pub struct OptimizationDiagnostic<'ll> {
36 pub kind: OptimizationDiagnosticKind,
37 pub pass_name: String,
38 pub function: &'ll Value,
45 impl OptimizationDiagnostic<'ll> {
46 unsafe fn unpack(kind: OptimizationDiagnosticKind, di: &'ll DiagnosticInfo) -> Self {
47 let mut function = None;
51 let mut message = None;
52 let mut filename = None;
53 let pass_name = super::build_string(|pass_name| {
54 message = super::build_string(|message| {
55 filename = super::build_string(|filename| {
56 super::LLVMRustUnpackOptimizationDiagnostic(
72 let mut filename = filename.unwrap_or_default();
73 if filename.is_empty() {
74 filename.push_str("<unknown file>");
77 OptimizationDiagnostic {
79 pass_name: pass_name.expect("got a non-UTF8 pass name from LLVM"),
80 function: function.unwrap(),
84 message: message.expect("got a non-UTF8 OptimizationDiagnostic message from LLVM"),
89 #[derive(Copy, Clone)]
90 pub struct InlineAsmDiagnostic<'ll> {
91 pub level: super::DiagnosticLevel,
93 pub message: &'ll Twine,
94 pub instruction: Option<&'ll Value>,
97 impl InlineAsmDiagnostic<'ll> {
98 unsafe fn unpack(di: &'ll DiagnosticInfo) -> Self {
100 let mut message = None;
101 let mut instruction = None;
102 let mut level = super::DiagnosticLevel::Error;
104 super::LLVMRustUnpackInlineAsmDiagnostic(
112 InlineAsmDiagnostic { level, cookie, message: message.unwrap(), instruction }
116 pub enum Diagnostic<'ll> {
117 Optimization(OptimizationDiagnostic<'ll>),
118 InlineAsm(InlineAsmDiagnostic<'ll>),
119 PGO(&'ll DiagnosticInfo),
120 Linker(&'ll DiagnosticInfo),
121 Unsupported(&'ll DiagnosticInfo),
123 /// LLVM has other types that we do not wrap here.
124 UnknownDiagnostic(&'ll DiagnosticInfo),
127 impl Diagnostic<'ll> {
128 pub unsafe fn unpack(di: &'ll DiagnosticInfo) -> Self {
129 use super::DiagnosticKind as Dk;
130 let kind = super::LLVMRustGetDiagInfoKind(di);
133 Dk::InlineAsm => InlineAsm(InlineAsmDiagnostic::unpack(di)),
135 Dk::OptimizationRemark => {
136 Optimization(OptimizationDiagnostic::unpack(OptimizationRemark, di))
138 Dk::OptimizationRemarkOther => {
139 Optimization(OptimizationDiagnostic::unpack(OptimizationRemarkOther, di))
141 Dk::OptimizationRemarkMissed => {
142 Optimization(OptimizationDiagnostic::unpack(OptimizationMissed, di))
145 Dk::OptimizationRemarkAnalysis => {
146 Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysis, di))
149 Dk::OptimizationRemarkAnalysisFPCommute => {
150 Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisFPCommute, di))
153 Dk::OptimizationRemarkAnalysisAliasing => {
154 Optimization(OptimizationDiagnostic::unpack(OptimizationAnalysisAliasing, di))
157 Dk::OptimizationFailure => {
158 Optimization(OptimizationDiagnostic::unpack(OptimizationFailure, di))
161 Dk::PGOProfile => PGO(di),
162 Dk::Linker => Linker(di),
163 Dk::Unsupported => Unsupported(di),
165 _ => UnknownDiagnostic(di),