llvmkit-asmparser 0.0.2

Lexer and parser for LLVM textual IR (.ll), mirroring llvm/lib/AsmParser.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Module summary index parser tests.

use llvmkit_asmparser::module_summary::GlobalValueSummary;
use llvmkit_asmparser::parser;

const SUMMARY: &str = include_str!("fixtures/summary_minimal.ll");

fn assert_summary_round_trip(printed: &str) {
    let expected = SUMMARY.replace("\r\n", "\n");
    assert_eq!(
        printed.trim_end_matches('\n'),
        expected.trim_end_matches('\n')
    );
}

/// Mirrors `LLParser.cpp::parseModuleEntry`.
#[test]
fn summary_module_entry_round_trips() {
    let index = parser::parse_summary_index_assembly(SUMMARY.as_bytes()).expect("summary parses");
    assert_eq!(index.modules.len(), 1);
    assert_eq!(index.modules[0].id, 1);
    assert_eq!(index.modules[0].path, "mod.ll");
    let printed = format!("{index}");
    assert_summary_round_trip(&printed);
}

/// Mirrors `LLParser.cpp::parseFunctionSummary`.
#[test]
fn summary_function_entry_round_trips() {
    let index = parser::parse_summary_index_assembly(SUMMARY.as_bytes()).expect("summary parses");
    let function = index
        .globals
        .iter()
        .flat_map(|gv| gv.summaries.iter())
        .find_map(|summary| match summary {
            GlobalValueSummary::Function(summary) => Some(summary),
            _ => None,
        })
        .expect("function summary present");
    assert_eq!(function.module, 1);
    assert_eq!(function.insts, 3);
    assert_eq!(function.calls.len(), 1);
    let printed = format!("{index}");
    assert_summary_round_trip(&printed);
}

/// Mirrors `LLParser.cpp::parseVariableSummary`.
#[test]
fn summary_variable_entry_round_trips() {
    let index = parser::parse_summary_index_assembly(SUMMARY.as_bytes()).expect("summary parses");
    let variable = index
        .globals
        .iter()
        .flat_map(|gv| gv.summaries.iter())
        .find_map(|summary| match summary {
            GlobalValueSummary::Variable(summary) => Some(summary),
            _ => None,
        })
        .expect("variable summary present");
    assert_eq!(variable.module, 1);
    assert_eq!(variable.refs.len(), 1);
    let printed = format!("{index}");
    assert_summary_round_trip(&printed);
}

/// Mirrors `LLParser.cpp::parseAliasSummary`.
#[test]
fn summary_alias_entry_round_trips() {
    let index = parser::parse_summary_index_assembly(SUMMARY.as_bytes()).expect("summary parses");
    let alias = index
        .globals
        .iter()
        .flat_map(|gv| gv.summaries.iter())
        .find_map(|summary| match summary {
            GlobalValueSummary::Alias(summary) => Some(summary),
            _ => None,
        })
        .expect("alias summary present");
    assert_eq!(alias.module, 1);
    assert!(alias.aliasee.is_some());
    let printed = format!("{index}");
    assert_summary_round_trip(&printed);
}

/// Mirrors `Parser.cpp::parseAssemblyFile` for summary indexes.
#[test]
fn parse_summary_index_assembly_file_reads_fixture() {
    let path = concat!(
        env!("CARGO_MANIFEST_DIR"),
        "/tests/fixtures/summary_minimal.ll"
    );
    let index = parser::parse_summary_index_assembly_file(path).expect("summary file parses");
    assert_eq!(index.flags.as_ref().map(|f| f.raw), Some(7));
    assert_eq!(index.block_count, Some(9));
}