radiance · Radiance self-hosting compiler

lib/std/arch/rv64/tests/abi.sizes.rad 3.4 KiB raw

//! Test size-based ABI: small aggregates (<= 8 bytes) are passed/returned
//! by value in registers, while larger aggregates use hidden pointers.

record Byte {
    x: u8,
}

record Short {
    x: u16,
}

record Word {
    x: u32,
}

record Pair {
    a: u32,
    b: u32,
}

record Triple {
    x: u32,
    y: u32,
    z: u32,
}

/// Return a 1-byte record by value.
fn makeByte(x: u8) -> Byte {
    return Byte { x };
}

/// Return a 2-byte record by value.
fn makeShort(x: u16) -> Short {
    return Short { x };
}

/// Return a 4-byte record by value.
fn makeWord(x: u32) -> Word {
    return Word { x };
}

/// Return an 8-byte record by value (boundary case).
fn makePair(a: u32, b: u32) -> Pair {
    return Pair { a, b };
}

/// Return a 12-byte record by reference (too large for register).
fn makeTriple(x: u32, y: u32, z: u32) -> Triple {
    return Triple { x, y, z };
}

/// Accept a small aggregate as parameter and return it.
fn identity(p: Pair) -> Pair {
    return p;
}

/// Accept multiple small aggregate args.
fn addPairs(a: Pair, b: Pair) -> Pair {
    return Pair { a: a.a + b.a, b: a.b + b.b };
}

/// Chain calls: result of one is arg to another.
fn doublePair(p: Pair) -> Pair {
    return addPairs(p, p);
}

/// Test 1-byte record.
fn testByte() -> i32 {
    let b = makeByte(42);
    assert b.x == 42;
    return 0;
}

/// Test 2-byte record.
fn testShort() -> i32 {
    let s = makeShort(1234);
    assert s.x == 1234;
    return 0;
}

/// Test 4-byte record.
fn testWord() -> i32 {
    let w = makeWord(0xDEAD);
    assert w.x == 0xDEAD;
    return 0;
}

/// Test 8-byte record (boundary case, should be by value).
fn testPair() -> i32 {
    let p = makePair(10, 20);
    assert p.a == 10;
    assert p.b == 20;
    return 0;
}

/// Test 12-byte record (should be by reference).
fn testTriple() -> i32 {
    let t = makeTriple(100, 200, 300);
    assert t.x == 100;
    assert t.y == 200;
    assert t.z == 300;
    return 0;
}

/// Test passing small aggregate as parameter and returning it.
fn testIdentity() -> i32 {
    let p = makePair(5, 6);
    let q = identity(p);
    assert q.a == 5;
    assert q.b == 6;
    return 0;
}

/// Test multiple small aggregate args.
fn testAddPairs() -> i32 {
    let a = makePair(1, 2);
    let b = makePair(3, 4);
    let c = addPairs(a, b);
    assert c.a == 4;
    assert c.b == 6;
    return 0;
}

/// Test chained calls.
fn testDoublePair() -> i32 {
    let p = makePair(10, 20);
    let d = doublePair(p);
    assert d.a == 20;
    assert d.b == 40;
    return 0;
}

/// Test multiple returns don't interfere.
fn testMultipleReturns() -> i32 {
    let p1 = makePair(1, 2);
    let p2 = makePair(3, 4);
    assert p1.a == 1;
    assert p1.b == 2;
    assert p2.a == 3;
    assert p2.b == 4;
    return 0;
}

@default fn main() -> i32 {
    let r1 = testByte();
    if r1 != 0 {
        return 10 + r1;
    }

    let r2 = testShort();
    if r2 != 0 {
        return 20 + r2;
    }

    let r3 = testWord();
    if r3 != 0 {
        return 30 + r3;
    }

    let r4 = testPair();
    if r4 != 0 {
        return 40 + r4;
    }

    let r5 = testTriple();
    if r5 != 0 {
        return 50 + r5;
    }

    let r6 = testIdentity();
    if r6 != 0 {
        return 60 + r6;
    }

    let r7 = testAddPairs();
    if r7 != 0 {
        return 70 + r7;
    }

    let r8 = testDoublePair();
    if r8 != 0 {
        return 80 + r8;
    }

    let r9 = testMultipleReturns();
    if r9 != 0 {
        return 90 + r9;
    }
    return 0;
}

1	//! Test size-based ABI: small aggregates (<= 8 bytes) are passed/returned
2	//! by value in registers, while larger aggregates use hidden pointers.
3
4	record Byte {
5	x: u8,
6	}
7
8	record Short {
9	x: u16,
10	}
11
12	record Word {
13	x: u32,
14	}
15
16	record Pair {
17	a: u32,
18	b: u32,
19	}
20
21	record Triple {
22	x: u32,
23	y: u32,
24	z: u32,
25	}
26
27	/// Return a 1-byte record by value.
28	fn makeByte(x: u8) -> Byte {
29	return Byte { x };
30	}
31
32	/// Return a 2-byte record by value.
33	fn makeShort(x: u16) -> Short {
34	return Short { x };
35	}
36
37	/// Return a 4-byte record by value.
38	fn makeWord(x: u32) -> Word {
39	return Word { x };
40	}
41
42	/// Return an 8-byte record by value (boundary case).
43	fn makePair(a: u32, b: u32) -> Pair {
44	return Pair { a, b };
45	}
46
47	/// Return a 12-byte record by reference (too large for register).
48	fn makeTriple(x: u32, y: u32, z: u32) -> Triple {
49	return Triple { x, y, z };
50	}
51
52	/// Accept a small aggregate as parameter and return it.
53	fn identity(p: Pair) -> Pair {
54	return p;
55	}
56
57	/// Accept multiple small aggregate args.
58	fn addPairs(a: Pair, b: Pair) -> Pair {
59	return Pair { a: a.a + b.a, b: a.b + b.b };
60	}
61
62	/// Chain calls: result of one is arg to another.
63	fn doublePair(p: Pair) -> Pair {
64	return addPairs(p, p);
65	}
66
67	/// Test 1-byte record.
68	fn testByte() -> i32 {
69	let b = makeByte(42);
70	assert b.x == 42;
71	return 0;
72	}
73
74	/// Test 2-byte record.
75	fn testShort() -> i32 {
76	let s = makeShort(1234);
77	assert s.x == 1234;
78	return 0;
79	}
80
81	/// Test 4-byte record.
82	fn testWord() -> i32 {
83	let w = makeWord(0xDEAD);
84	assert w.x == 0xDEAD;
85	return 0;
86	}
87
88	/// Test 8-byte record (boundary case, should be by value).
89	fn testPair() -> i32 {
90	let p = makePair(10, 20);
91	assert p.a == 10;
92	assert p.b == 20;
93	return 0;
94	}
95
96	/// Test 12-byte record (should be by reference).
97	fn testTriple() -> i32 {
98	let t = makeTriple(100, 200, 300);
99	assert t.x == 100;
100	assert t.y == 200;
101	assert t.z == 300;
102	return 0;
103	}
104
105	/// Test passing small aggregate as parameter and returning it.
106	fn testIdentity() -> i32 {
107	let p = makePair(5, 6);
108	let q = identity(p);
109	assert q.a == 5;
110	assert q.b == 6;
111	return 0;
112	}
113
114	/// Test multiple small aggregate args.
115	fn testAddPairs() -> i32 {
116	let a = makePair(1, 2);
117	let b = makePair(3, 4);
118	let c = addPairs(a, b);
119	assert c.a == 4;
120	assert c.b == 6;
121	return 0;
122	}
123
124	/// Test chained calls.
125	fn testDoublePair() -> i32 {
126	let p = makePair(10, 20);
127	let d = doublePair(p);
128	assert d.a == 20;
129	assert d.b == 40;
130	return 0;
131	}
132
133	/// Test multiple returns don't interfere.
134	fn testMultipleReturns() -> i32 {
135	let p1 = makePair(1, 2);
136	let p2 = makePair(3, 4);
137	assert p1.a == 1;
138	assert p1.b == 2;
139	assert p2.a == 3;
140	assert p2.b == 4;
141	return 0;
142	}
143
144	@default fn main() -> i32 {
145	let r1 = testByte();
146	if r1 != 0 {
147	return 10 + r1;
148	}
149
150	let r2 = testShort();
151	if r2 != 0 {
152	return 20 + r2;
153	}
154
155	let r3 = testWord();
156	if r3 != 0 {
157	return 30 + r3;
158	}
159
160	let r4 = testPair();
161	if r4 != 0 {
162	return 40 + r4;
163	}
164
165	let r5 = testTriple();
166	if r5 != 0 {
167	return 50 + r5;
168	}
169
170	let r6 = testIdentity();
171	if r6 != 0 {
172	return 60 + r6;
173	}
174
175	let r7 = testAddPairs();
176	if r7 != 0 {
177	return 70 + r7;
178	}
179
180	let r8 = testDoublePair();
181	if r8 != 0 {
182	return 80 + r8;
183	}
184
185	let r9 = testMultipleReturns();
186	if r9 != 0 {
187	return 90 + r9;
188	}
189	return 0;
190	}