lib/std/lang/il/link/tests.rad 7.5 KiB raw
1
//! Cross-package descriptor graph matching.
2
3
use std::lang::il;
4
use std::lang::il::link;
5
use std::mem::heap;
6
use std::testing;
7
8
/// Storage for bounded graph comparison.
9
static MEMORY: [u8; 32768] = [0; 32768];
10
11
/// Plain scalar layout used by pointer targets.
12
constant PLAIN: il::Layout = il::Layout { size: 4, alignment: 4, slots: &[], regions: 0 };
13
14
/// Construct a program with only a layout graph.
15
fn program(layouts: *[il::Layout]) -> il::Program {
16
    return il::Program { data: &[], fns: &[], layouts, signatures: &[], traits: &[] };
17
}
18
19
/// Construct a provider declaration from a test signature.
20
fn declaration(signature: il::Signature, arena: &heap::Heap) -> il::Fn {
21
    let mut params: *mut [il::Param] = &mut [];
22
    for typ, i in signature.params {
23
        try! params.append(il::Param { value: il::Reg { n: i }, type: typ }, arena);
24
    }
25
    return il::Fn {
26
        name: "provider::call",
27
        params: &params[..],
28
        returnType: signature.ret,
29
        isExtern: true,
30
        isLeaf: true,
31
        blocks: &[],
32
        vals: &[],
33
        cases: &[],
34
        borrows: signature.borrows,
35
    };
36
}
37
38
/// A cyclic graph matches with different package-local layout indices.
39
@test unsafe fn recursiveLayouts() throws (testing::TestError) {
40
    let left = program(&[
41
        il::Layout {
42
            size: 8,
43
            alignment: 8,
44
            slots: &[
45
                il::Slot {
46
                    offset: 0,
47
                    kind: il::SlotKind::Ptr(il::PtrType {
48
                        layout: 0, own: true, mutable: false, nullable: true
49
                    }),
50
                    regions: &[],
51
                },
52
            ],
53
            regions: 0,
54
        },
55
    ]);
56
    let right = program(
57
        &[
58
            il::Layout { size: 1, alignment: 1, slots: &[], regions: 0 },
59
            il::Layout {
60
                size: 8,
61
                alignment: 8,
62
                slots: &[
63
                    il::Slot {
64
                        offset: 0,
65
                        kind: il::SlotKind::Ptr(il::PtrType {
66
                            layout: 1, own: true, mutable: false, nullable: true
67
                        }),
68
                        regions: &[],
69
                    },
70
                ],
71
                regions: 0,
72
            },
73
        ]
74
    );
75
    let arena = heap::over(&mut MEMORY[..]);
76
    let mut work = try! link::workspace(32, arena);
77
    assert try! link::sameLayout(&mut work, &left, 0, &right, 1);
78
    assert not try! link::sameLayout(&mut work, &left, 0, &right, 0);
79
    assert try! link::sameLayout(&mut work, &left, 0, &right, 1);
80
}
81
82
/// Pointer rights are checked after following an otherwise equal outer layout.
83
@test unsafe fn nestedRights() throws (testing::TestError) {
84
    let left = program(
85
        &[
86
            PLAIN,
87
            il::Layout {
88
                size: 8,
89
                alignment: 8,
90
                slots: &[
91
                    il::Slot {
92
                        offset: 0,
93
                        kind: il::SlotKind::Ptr(il::PtrType {
94
                            layout: 0, own: true, mutable: true, nullable: true
95
                        }),
96
                        regions: &[],
97
                    },
98
                ],
99
                regions: 0,
100
            },
101
        ]
102
    );
103
    let right = program(
104
        &[
105
            PLAIN,
106
            il::Layout {
107
                size: 8,
108
                alignment: 8,
109
                slots: &[
110
                    il::Slot {
111
                        offset: 0,
112
                        kind: il::SlotKind::Ptr(il::PtrType {
113
                            layout: 0, own: true, mutable: false, nullable: true
114
                        }),
115
                        regions: &[],
116
                    },
117
                ],
118
                regions: 0,
119
            },
120
        ]
121
    );
122
    let arena = heap::over(&mut MEMORY[..]);
123
    let mut work = try! link::workspace(32, arena);
124
    assert not try! link::sameLayout(&mut work, &left, 1, &right, 1);
125
}
126
127
/// Borrow source positions must match even when all physical types match.
128
@test unsafe fn borrowSources() throws (testing::TestError) {
129
    let pointer = il::ValType::Ptr(il::PtrType {
130
        layout: 0, own: false, mutable: false, nullable: false
131
    });
132
    let mut params: *mut [il::ValType] = &mut [];
133
    let arena = heap::over(&mut MEMORY[..]);
134
    try! params.append(pointer, arena);
135
    try! params.append(pointer, arena);
136
    let mut signatures: *mut [il::Signature] = &mut [];
137
    try! signatures.append(
138
        il::Signature {
139
            params: &params[..],
140
            ret: pointer,
141
            borrows: &[
142
                il::Borrow { target: nil, result: 0, param: 0, source: nil }
143
            ],
144
        },
145
        arena
146
    );
147
    let left = il::Program {
148
        data: &[], fns: &[], layouts: &[PLAIN], signatures: &signatures[..], traits: &[]
149
    };
150
    let mut right = left;
151
    let mut changed: *mut [il::Signature] = &mut [];
152
    try! changed.append(
153
        il::Signature {
154
            params: left.signatures[0].params,
155
            ret: pointer,
156
            borrows: &[
157
                il::Borrow { target: nil, result: 0, param: 1, source: nil }
158
            ],
159
        },
160
        arena
161
    );
162
    set right.signatures = &changed[..];
163
    let mut work = try! link::workspace(8, arena);
164
    let mut callable = declaration(left.signatures[0], arena);
165
    assert try! link::sameCallable(&mut work, &left, &left.signatures[0], &left, &callable);
166
    set callable.borrows = right.signatures[0].borrows;
167
    assert not try! link::sameCallable(&mut work, &left, &left.signatures[0], &right, &callable);
168
}
169
170
/// Method receivers and nested scalar widths are part of trait contracts.
171
@test unsafe fn traitContracts() throws (testing::TestError) {
172
    let left = il::Program {
173
        data: &[],
174
        fns: &[],
175
        layouts: &[
176
            il::Layout {
177
                size: 16,
178
                alignment: 8,
179
                slots: &[
180
                    il::Slot {
181
                        offset: 0,
182
                        kind: il::SlotKind::Trait(il::ObjectType {
183
                            iface: 0, own: false, mutable: false
184
                        }),
185
                        regions: &[0],
186
                    },
187
                ],
188
                regions: 1,
189
            },
190
        ],
191
        signatures: &[
192
            il::Signature { params: &[], ret: il::ValType::Data(il::Type::W32), borrows: &[] }
193
        ],
194
        traits: &[
195
            il::Trait {
196
                methods: &[
197
                    il::Method { sig: 0, receiver: 0, own: false, mutable: false }
198
                ],
199
            },
200
        ],
201
    };
202
    let arena = heap::over(&mut MEMORY[..]);
203
    let mut work = try! link::workspace(8, arena);
204
    assert try! link::sameLayout(&mut work, &left, 0, &left, 0);
205
    let mut right = left;
206
    set right.traits = &[
207
        il::Trait {
208
            methods: &[
209
                il::Method { sig: 0, receiver: 0, own: false, mutable: true }
210
            ],
211
        },
212
    ];
213
    assert not try! link::sameLayout(&mut work, &left, 0, &right, 0);
214
    set right.traits = left.traits;
215
    set right.signatures = &[
216
        il::Signature { params: &[], ret: il::ValType::Data(il::Type::W64), borrows: &[] }
217
    ];
218
    assert not try! link::sameLayout(&mut work, &left, 0, &right, 0);
219
    let mut small = try! link::workspace(1, arena);
220
    let mut limited = false;
221
    try link::sameLayout(&mut small, &left, 0, &left, 0) catch error {
222
        assert error == link::Error::Limit;
223
        set limited = true;
224
    };
225
    assert limited;
226
    let callable = declaration(left.signatures[0], arena);
227
    assert try! link::sameCallable(&mut small, &left, &left.signatures[0], &left, &callable);
228
}