.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
lang/
alloc/
ast/
gen/
il/
binary/
link/
tests.rad
7.5 KiB
printer/
verify/
binary.rad
14.7 KiB
link.rad
11.8 KiB
printer.rad
31.7 KiB
verify.rad
99.5 KiB
layout/
lower/
manifest/
module/
parser/
resolver/
scanner/
sexpr/
alloc.rad
1.2 KiB
ast.rad
36.0 KiB
gen.rad
513 B
il.rad
48.5 KiB
layout.rad
6.9 KiB
lower.rad
487.6 KiB
manifest.rad
22.5 KiB
module.rad
17.8 KiB
package.rad
1.5 KiB
parser.rad
114.1 KiB
pretty.rad
103.6 KiB
resolver.rad
508.1 KiB
scanner.rad
19.3 KiB
sexpr.rad
7.1 KiB
strings.rad
3.3 KiB
types.rad
620 B
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/lang/il/link/tests.rad
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: ¶ms[..], |
| 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: ¶ms[..], |
| 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 | } |