authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-05-17 14:39:56-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-05-17 16:09:20-07:00
log8a7a07f30dc9aedb596db327f57d5dc12f2ffd52
tree365b7090109244daa620afd42820ee62da2b2d03
parent83677074f95930d0fcb95a4eed276637d52afde7

stage2: test cases take advantage of `pub fn main` support

3 files changed, 62 insertions(+), 602 deletions(-)

BRANCH_TODO-2
......@@ -1,5 +1,3 @@
1 * modify stage2 tests so that only 1 uses _start and the rest use
2 pub fn main
31 * modify stage2 CBE tests so that only 1 uses pub export main and the
42 rest use pub fn main
53
test/stage2/arm.zig+14-157
......@@ -9,7 +9,7 @@ const linux_arm = std.zig.CrossTarget{
99pub fn addCases(ctx: *TestContext) !void {
1010 {
1111 var case = ctx.exe("linux_arm hello world", linux_arm);
12 // Regular old hello world
12 // Hello world using _start and inline asm.
1313 case.addCompareOutput(
1414 \\pub export fn _start() noreturn {
1515 \\ print();
......@@ -50,9 +50,8 @@ pub fn addCases(ctx: *TestContext) !void {
5050 // be in a specific order because otherwise the write to r0
5151 // would overwrite the len parameter which resides in r0
5252 case.addCompareOutput(
53 \\pub export fn _start() noreturn {
53 \\pub fn main() void {
5454 \\ print(id(14));
55 \\ exit();
5655 \\}
5756 \\
5857 \\fn id(x: u32) u32 {
......@@ -70,16 +69,6 @@ pub fn addCases(ctx: *TestContext) !void {
7069 \\ );
7170 \\ return;
7271 \\}
73 \\
74 \\fn exit() noreturn {
75 \\ asm volatile ("svc #0"
76 \\ :
77 \\ : [number] "{r7}" (1),
78 \\ [arg1] "{r0}" (0)
79 \\ : "memory"
80 \\ );
81 \\ unreachable;
82 \\}
8372 ,
8473 "Hello, World!\n",
8574 );
......@@ -89,9 +78,8 @@ pub fn addCases(ctx: *TestContext) !void {
8978 var case = ctx.exe("non-leaf functions", linux_arm);
9079 // Testing non-leaf functions
9180 case.addCompareOutput(
92 \\pub export fn _start() noreturn {
81 \\pub fn main() void {
9382 \\ foo();
94 \\ exit();
9583 \\}
9684 \\
9785 \\fn foo() void {
......@@ -99,16 +87,6 @@ pub fn addCases(ctx: *TestContext) !void {
9987 \\}
10088 \\
10189 \\fn bar() void {}
102 \\
103 \\fn exit() noreturn {
104 \\ asm volatile ("svc #0"
105 \\ :
106 \\ : [number] "{r7}" (1),
107 \\ [arg1] "{r0}" (0)
108 \\ : "memory"
109 \\ );
110 \\ unreachable;
111 \\}
11290 ,
11391 "",
11492 );
......@@ -119,10 +97,9 @@ pub fn addCases(ctx: *TestContext) !void {
11997
12098 // Add two numbers
12199 case.addCompareOutput(
122 \\pub export fn _start() noreturn {
100 \\pub fn main() void {
123101 \\ print(2, 4);
124102 \\ print(1, 7);
125 \\ exit();
126103 \\}
127104 \\
128105 \\fn print(a: u32, b: u32) void {
......@@ -136,26 +113,15 @@ pub fn addCases(ctx: *TestContext) !void {
136113 \\ );
137114 \\ return;
138115 \\}
139 \\
140 \\fn exit() noreturn {
141 \\ asm volatile ("svc #0"
142 \\ :
143 \\ : [number] "{r7}" (1),
144 \\ [arg1] "{r0}" (0)
145 \\ : "memory"
146 \\ );
147 \\ unreachable;
148 \\}
149116 ,
150117 "12345612345678",
151118 );
152119
153120 // Subtract two numbers
154121 case.addCompareOutput(
155 \\pub export fn _start() noreturn {
122 \\pub fn main() void {
156123 \\ print(10, 5);
157124 \\ print(4, 3);
158 \\ exit();
159125 \\}
160126 \\
161127 \\fn print(a: u32, b: u32) void {
......@@ -169,26 +135,15 @@ pub fn addCases(ctx: *TestContext) !void {
169135 \\ );
170136 \\ return;
171137 \\}
172 \\
173 \\fn exit() noreturn {
174 \\ asm volatile ("svc #0"
175 \\ :
176 \\ : [number] "{r7}" (1),
177 \\ [arg1] "{r0}" (0)
178 \\ : "memory"
179 \\ );
180 \\ unreachable;
181 \\}
182138 ,
183139 "123451",
184140 );
185141
186142 // Bitwise And
187143 case.addCompareOutput(
188 \\pub export fn _start() noreturn {
144 \\pub fn main() void {
189145 \\ print(8, 9);
190146 \\ print(3, 7);
191 \\ exit();
192147 \\}
193148 \\
194149 \\fn print(a: u32, b: u32) void {
......@@ -202,26 +157,15 @@ pub fn addCases(ctx: *TestContext) !void {
202157 \\ );
203158 \\ return;
204159 \\}
205 \\
206 \\fn exit() noreturn {
207 \\ asm volatile ("svc #0"
208 \\ :
209 \\ : [number] "{r7}" (1),
210 \\ [arg1] "{r0}" (0)
211 \\ : "memory"
212 \\ );
213 \\ unreachable;
214 \\}
215160 ,
216161 "12345678123",
217162 );
218163
219164 // Bitwise Or
220165 case.addCompareOutput(
221 \\pub export fn _start() noreturn {
166 \\pub fn main() void {
222167 \\ print(4, 2);
223168 \\ print(3, 7);
224 \\ exit();
225169 \\}
226170 \\
227171 \\fn print(a: u32, b: u32) void {
......@@ -235,26 +179,15 @@ pub fn addCases(ctx: *TestContext) !void {
235179 \\ );
236180 \\ return;
237181 \\}
238 \\
239 \\fn exit() noreturn {
240 \\ asm volatile ("svc #0"
241 \\ :
242 \\ : [number] "{r7}" (1),
243 \\ [arg1] "{r0}" (0)
244 \\ : "memory"
245 \\ );
246 \\ unreachable;
247 \\}
248182 ,
249183 "1234561234567",
250184 );
251185
252186 // Bitwise Xor
253187 case.addCompareOutput(
254 \\pub export fn _start() noreturn {
188 \\pub fn main() void {
255189 \\ print(42, 42);
256190 \\ print(3, 5);
257 \\ exit();
258191 \\}
259192 \\
260193 \\fn print(a: u32, b: u32) void {
......@@ -268,16 +201,6 @@ pub fn addCases(ctx: *TestContext) !void {
268201 \\ );
269202 \\ return;
270203 \\}
271 \\
272 \\fn exit() noreturn {
273 \\ asm volatile ("svc #0"
274 \\ :
275 \\ : [number] "{r7}" (1),
276 \\ [arg1] "{r0}" (0)
277 \\ : "memory"
278 \\ );
279 \\ unreachable;
280 \\}
281204 ,
282205 "123456",
283206 );
......@@ -287,26 +210,15 @@ pub fn addCases(ctx: *TestContext) !void {
287210 var case = ctx.exe("if statements", linux_arm);
288211 // Simple if statement in assert
289212 case.addCompareOutput(
290 \\pub export fn _start() noreturn {
213 \\pub fn main() void {
291214 \\ var x: u32 = 123;
292215 \\ var y: u32 = 42;
293216 \\ assert(x > y);
294 \\ exit();
295217 \\}
296218 \\
297219 \\fn assert(ok: bool) void {
298220 \\ if (!ok) unreachable;
299221 \\}
300 \\
301 \\fn exit() noreturn {
302 \\ asm volatile ("svc #0"
303 \\ :
304 \\ : [number] "{r7}" (1),
305 \\ [arg1] "{r0}" (0)
306 \\ : "memory"
307 \\ );
308 \\ unreachable;
309 \\}
310222 ,
311223 "",
312224 );
......@@ -316,7 +228,7 @@ pub fn addCases(ctx: *TestContext) !void {
316228 var case = ctx.exe("while loops", linux_arm);
317229 // Simple while loop with assert
318230 case.addCompareOutput(
319 \\pub export fn _start() noreturn {
231 \\pub fn main() void {
320232 \\ var x: u32 = 2020;
321233 \\ var i: u32 = 0;
322234 \\ while (x > 0) {
......@@ -324,22 +236,11 @@ pub fn addCases(ctx: *TestContext) !void {
324236 \\ i += 1;
325237 \\ }
326238 \\ assert(i == 1010);
327 \\ exit();
328239 \\}
329240 \\
330241 \\fn assert(ok: bool) void {
331242 \\ if (!ok) unreachable;
332243 \\}
333 \\
334 \\fn exit() noreturn {
335 \\ asm volatile ("svc #0"
336 \\ :
337 \\ : [number] "{r7}" (1),
338 \\ [arg1] "{r0}" (0)
339 \\ : "memory"
340 \\ );
341 \\ unreachable;
342 \\}
343244 ,
344245 "",
345246 );
......@@ -349,12 +250,11 @@ pub fn addCases(ctx: *TestContext) !void {
349250 var case = ctx.exe("integer multiplication", linux_arm);
350251 // Simple u32 integer multiplication
351252 case.addCompareOutput(
352 \\pub export fn _start() noreturn {
253 \\pub fn main() void {
353254 \\ assert(mul(1, 1) == 1);
354255 \\ assert(mul(42, 1) == 42);
355256 \\ assert(mul(1, 42) == 42);
356257 \\ assert(mul(123, 42) == 5166);
357 \\ exit();
358258 \\}
359259 \\
360260 \\fn mul(x: u32, y: u32) u32 {
......@@ -364,16 +264,6 @@ pub fn addCases(ctx: *TestContext) !void {
364264 \\fn assert(ok: bool) void {
365265 \\ if (!ok) unreachable;
366266 \\}
367 \\
368 \\fn exit() noreturn {
369 \\ asm volatile ("svc #0"
370 \\ :
371 \\ : [number] "{r7}" (1),
372 \\ [arg1] "{r0}" (0)
373 \\ : "memory"
374 \\ );
375 \\ unreachable;
376 \\}
377267 ,
378268 "",
379269 );
......@@ -385,9 +275,8 @@ pub fn addCases(ctx: *TestContext) !void {
385275 // callee preserved register, otherwise it will be overwritten
386276 // by the first parameter to baz.
387277 case.addCompareOutput(
388 \\pub export fn _start() noreturn {
278 \\pub fn main() void {
389279 \\ assert(foo() == 43);
390 \\ exit();
391280 \\}
392281 \\
393282 \\fn foo() u32 {
......@@ -405,16 +294,6 @@ pub fn addCases(ctx: *TestContext) !void {
405294 \\fn assert(ok: bool) void {
406295 \\ if (!ok) unreachable;
407296 \\}
408 \\
409 \\fn exit() noreturn {
410 \\ asm volatile ("svc #0"
411 \\ :
412 \\ : [number] "{r7}" (1),
413 \\ [arg1] "{r0}" (0)
414 \\ : "memory"
415 \\ );
416 \\ unreachable;
417 \\}
418297 ,
419298 "",
420299 );
......@@ -423,14 +302,13 @@ pub fn addCases(ctx: *TestContext) !void {
423302 {
424303 var case = ctx.exe("recursive fibonacci", linux_arm);
425304 case.addCompareOutput(
426 \\pub export fn _start() noreturn {
305 \\pub fn main() void {
427306 \\ assert(fib(0) == 0);
428307 \\ assert(fib(1) == 1);
429308 \\ assert(fib(2) == 1);
430309 \\ assert(fib(3) == 2);
431310 \\ assert(fib(10) == 55);
432311 \\ assert(fib(20) == 6765);
433 \\ exit();
434312 \\}
435313 \\
436314 \\fn fib(n: u32) u32 {
......@@ -444,16 +322,6 @@ pub fn addCases(ctx: *TestContext) !void {
444322 \\fn assert(ok: bool) void {
445323 \\ if (!ok) unreachable;
446324 \\}
447 \\
448 \\fn exit() noreturn {
449 \\ asm volatile ("svc #0"
450 \\ :
451 \\ : [number] "{r7}" (1),
452 \\ [arg1] "{r0}" (0)
453 \\ : "memory"
454 \\ );
455 \\ unreachable;
456 \\}
457325 ,
458326 "",
459327 );
......@@ -462,9 +330,8 @@ pub fn addCases(ctx: *TestContext) !void {
462330 {
463331 var case = ctx.exe("spilling registers", linux_arm);
464332 case.addCompareOutput(
465 \\pub export fn _start() noreturn {
333 \\pub fn main() void {
466334 \\ assert(add(3, 4) == 791);
467 \\ exit();
468335 \\}
469336 \\
470337 \\fn add(a: u32, b: u32) u32 {
......@@ -497,16 +364,6 @@ pub fn addCases(ctx: *TestContext) !void {
497364 \\fn assert(ok: bool) void {
498365 \\ if (!ok) unreachable;
499366 \\}
500 \\
501 \\fn exit() noreturn {
502 \\ asm volatile ("svc #0"
503 \\ :
504 \\ : [number] "{r7}" (1),
505 \\ [arg1] "{r0}" (0)
506 \\ : "memory"
507 \\ );
508 \\ unreachable;
509 \\}
510367 ,
511368 "",
512369 );
test/stage2/test.zig+48-443
......@@ -65,6 +65,7 @@ pub fn addCases(ctx: *TestContext) !void {
6565 ,
6666 "Hello, World!\n",
6767 );
68
6869 // Now change the message only
6970 case.addCompareOutput(
7071 \\pub export fn _start() noreturn {
......@@ -237,25 +238,13 @@ pub fn addCases(ctx: *TestContext) !void {
237238 {
238239 var case = ctx.exe("subtracting numbers at runtime", linux_x64);
239240 case.addCompareOutput(
240 \\pub export fn _start() noreturn {
241 \\pub fn main() void {
241242 \\ sub(7, 4);
242 \\
243 \\ exit();
244243 \\}
245244 \\
246245 \\fn sub(a: u32, b: u32) void {
247246 \\ if (a - b != 3) unreachable;
248247 \\}
249 \\
250 \\fn exit() noreturn {
251 \\ asm volatile ("syscall"
252 \\ :
253 \\ : [number] "{rax}" (231),
254 \\ [arg1] "{rdi}" (0)
255 \\ : "rcx", "r11", "memory"
256 \\ );
257 \\ unreachable;
258 \\}
259248 ,
260249 "",
261250 );
......@@ -263,58 +252,33 @@ pub fn addCases(ctx: *TestContext) !void {
263252 {
264253 var case = ctx.exe("@TypeOf", linux_x64);
265254 case.addCompareOutput(
266 \\pub export fn _start() noreturn {
255 \\pub fn main() void {
267256 \\ var x: usize = 0;
268257 \\ const z = @TypeOf(x, @as(u128, 5));
269258 \\ assert(z == u128);
270 \\
271 \\ exit();
272259 \\}
273260 \\
274261 \\pub fn assert(ok: bool) void {
275262 \\ if (!ok) unreachable; // assertion failure
276263 \\}
277 \\
278 \\fn exit() noreturn {
279 \\ asm volatile ("syscall"
280 \\ :
281 \\ : [number] "{rax}" (231),
282 \\ [arg1] "{rdi}" (0)
283 \\ : "rcx", "r11", "memory"
284 \\ );
285 \\ unreachable;
286 \\}
287264 ,
288265 "",
289266 );
290267 case.addCompareOutput(
291 \\pub export fn _start() noreturn {
268 \\pub fn main() void {
292269 \\ const z = @TypeOf(true);
293270 \\ assert(z == bool);
294 \\
295 \\ exit();
296271 \\}
297272 \\
298273 \\pub fn assert(ok: bool) void {
299274 \\ if (!ok) unreachable; // assertion failure
300275 \\}
301 \\
302 \\fn exit() noreturn {
303 \\ asm volatile ("syscall"
304 \\ :
305 \\ : [number] "{rax}" (231),
306 \\ [arg1] "{rdi}" (0)
307 \\ : "rcx", "r11", "memory"
308 \\ );
309 \\ unreachable;
310 \\}
311276 ,
312277 "",
313278 );
314279 case.addError(
315 \\pub export fn _start() noreturn {
280 \\pub fn main() void {
316281 \\ const z = @TypeOf(true, 1);
317 \\ unreachable;
318282 \\}
319283 , &[_][]const u8{":2:15: error: incompatible types: 'bool' and 'comptime_int'"});
320284 }
......@@ -346,7 +310,7 @@ pub fn addCases(ctx: *TestContext) !void {
346310 );
347311 // comptime function call
348312 case.addCompareOutput(
349 \\pub export fn _start() noreturn {
313 \\pub fn _start() noreturn {
350314 \\ exit();
351315 \\}
352316 \\
......@@ -397,10 +361,8 @@ pub fn addCases(ctx: *TestContext) !void {
397361 {
398362 var case = ctx.exe("assert function", linux_x64);
399363 case.addCompareOutput(
400 \\pub export fn _start() noreturn {
364 \\pub fn main() void {
401365 \\ add(3, 4);
402 \\
403 \\ exit();
404366 \\}
405367 \\
406368 \\fn add(a: u32, b: u32) void {
......@@ -427,10 +389,8 @@ pub fn addCases(ctx: *TestContext) !void {
427389 // Tests copying a register. For the `c = a + b`, it has to
428390 // preserve both a and b, because they are both used later.
429391 case.addCompareOutput(
430 \\pub export fn _start() noreturn {
392 \\pub fn main() void {
431393 \\ add(3, 4);
432 \\
433 \\ exit();
434394 \\}
435395 \\
436396 \\fn add(a: u32, b: u32) void {
......@@ -443,26 +403,14 @@ pub fn addCases(ctx: *TestContext) !void {
443403 \\pub fn assert(ok: bool) void {
444404 \\ if (!ok) unreachable; // assertion failure
445405 \\}
446 \\
447 \\fn exit() noreturn {
448 \\ asm volatile ("syscall"
449 \\ :
450 \\ : [number] "{rax}" (231),
451 \\ [arg1] "{rdi}" (0)
452 \\ : "rcx", "r11", "memory"
453 \\ );
454 \\ unreachable;
455 \\}
456406 ,
457407 "",
458408 );
459409
460410 // More stress on the liveness detection.
461411 case.addCompareOutput(
462 \\pub export fn _start() noreturn {
412 \\pub fn main() void {
463413 \\ add(3, 4);
464 \\
465 \\ exit();
466414 \\}
467415 \\
468416 \\fn add(a: u32, b: u32) void {
......@@ -479,26 +427,14 @@ pub fn addCases(ctx: *TestContext) !void {
479427 \\pub fn assert(ok: bool) void {
480428 \\ if (!ok) unreachable; // assertion failure
481429 \\}
482 \\
483 \\fn exit() noreturn {
484 \\ asm volatile ("syscall"
485 \\ :
486 \\ : [number] "{rax}" (231),
487 \\ [arg1] "{rdi}" (0)
488 \\ : "rcx", "r11", "memory"
489 \\ );
490 \\ unreachable;
491 \\}
492430 ,
493431 "",
494432 );
495433
496434 // Requires a second move. The register allocator should figure out to re-use rax.
497435 case.addCompareOutput(
498 \\pub export fn _start() noreturn {
436 \\pub fn main() void {
499437 \\ add(3, 4);
500 \\
501 \\ exit();
502438 \\}
503439 \\
504440 \\fn add(a: u32, b: u32) void {
......@@ -516,27 +452,15 @@ pub fn addCases(ctx: *TestContext) !void {
516452 \\pub fn assert(ok: bool) void {
517453 \\ if (!ok) unreachable; // assertion failure
518454 \\}
519 \\
520 \\fn exit() noreturn {
521 \\ asm volatile ("syscall"
522 \\ :
523 \\ : [number] "{rax}" (231),
524 \\ [arg1] "{rdi}" (0)
525 \\ : "rcx", "r11", "memory"
526 \\ );
527 \\ unreachable;
528 \\}
529455 ,
530456 "",
531457 );
532458
533459 // Now we test integer return values.
534460 case.addCompareOutput(
535 \\pub export fn _start() noreturn {
461 \\pub fn main() void {
536462 \\ assert(add(3, 4) == 7);
537463 \\ assert(add(20, 10) == 30);
538 \\
539 \\ exit();
540464 \\}
541465 \\
542466 \\fn add(a: u32, b: u32) u32 {
......@@ -546,27 +470,15 @@ pub fn addCases(ctx: *TestContext) !void {
546470 \\pub fn assert(ok: bool) void {
547471 \\ if (!ok) unreachable; // assertion failure
548472 \\}
549 \\
550 \\fn exit() noreturn {
551 \\ asm volatile ("syscall"
552 \\ :
553 \\ : [number] "{rax}" (231),
554 \\ [arg1] "{rdi}" (0)
555 \\ : "rcx", "r11", "memory"
556 \\ );
557 \\ unreachable;
558 \\}
559473 ,
560474 "",
561475 );
562476
563477 // Local mutable variables.
564478 case.addCompareOutput(
565 \\pub export fn _start() noreturn {
479 \\pub fn main() void {
566480 \\ assert(add(3, 4) == 7);
567481 \\ assert(add(20, 10) == 30);
568 \\
569 \\ exit();
570482 \\}
571483 \\
572484 \\fn add(a: u32, b: u32) u32 {
......@@ -580,39 +492,17 @@ pub fn addCases(ctx: *TestContext) !void {
580492 \\pub fn assert(ok: bool) void {
581493 \\ if (!ok) unreachable; // assertion failure
582494 \\}
583 \\
584 \\fn exit() noreturn {
585 \\ asm volatile ("syscall"
586 \\ :
587 \\ : [number] "{rax}" (231),
588 \\ [arg1] "{rdi}" (0)
589 \\ : "rcx", "r11", "memory"
590 \\ );
591 \\ unreachable;
592 \\}
593495 ,
594496 "",
595497 );
596498
597499 // Optionals
598500 case.addCompareOutput(
599 \\pub export fn _start() noreturn {
501 \\pub fn main() void {
600502 \\ const a: u32 = 2;
601503 \\ const b: ?u32 = a;
602504 \\ const c = b.?;
603505 \\ if (c != 2) unreachable;
604 \\
605 \\ exit();
606 \\}
607 \\
608 \\fn exit() noreturn {
609 \\ asm volatile ("syscall"
610 \\ :
611 \\ : [number] "{rax}" (231),
612 \\ [arg1] "{rdi}" (0)
613 \\ : "rcx", "r11", "memory"
614 \\ );
615 \\ unreachable;
616506 \\}
617507 ,
618508 "",
......@@ -620,12 +510,10 @@ pub fn addCases(ctx: *TestContext) !void {
620510
621511 // While loops
622512 case.addCompareOutput(
623 \\pub export fn _start() noreturn {
513 \\pub fn main() void {
624514 \\ var i: u32 = 0;
625515 \\ while (i < 4) : (i += 1) print();
626516 \\ assert(i == 4);
627 \\
628 \\ exit();
629517 \\}
630518 \\
631519 \\fn print() void {
......@@ -643,28 +531,16 @@ pub fn addCases(ctx: *TestContext) !void {
643531 \\pub fn assert(ok: bool) void {
644532 \\ if (!ok) unreachable; // assertion failure
645533 \\}
646 \\
647 \\fn exit() noreturn {
648 \\ asm volatile ("syscall"
649 \\ :
650 \\ : [number] "{rax}" (231),
651 \\ [arg1] "{rdi}" (0)
652 \\ : "rcx", "r11", "memory"
653 \\ );
654 \\ unreachable;
655 \\}
656534 ,
657535 "hello\nhello\nhello\nhello\n",
658536 );
659537
660538 // inline while requires the condition to be comptime known.
661539 case.addError(
662 \\pub export fn _start() noreturn {
540 \\pub fn main() void {
663541 \\ var i: u32 = 0;
664542 \\ inline while (i < 4) : (i += 1) print();
665543 \\ assert(i == 4);
666 \\
667 \\ exit();
668544 \\}
669545 \\
670546 \\fn print() void {
......@@ -682,24 +558,12 @@ pub fn addCases(ctx: *TestContext) !void {
682558 \\pub fn assert(ok: bool) void {
683559 \\ if (!ok) unreachable; // assertion failure
684560 \\}
685 \\
686 \\fn exit() noreturn {
687 \\ asm volatile ("syscall"
688 \\ :
689 \\ : [number] "{rax}" (231),
690 \\ [arg1] "{rdi}" (0)
691 \\ : "rcx", "r11", "memory"
692 \\ );
693 \\ unreachable;
694 \\}
695561 , &[_][]const u8{":3:21: error: unable to resolve comptime value"});
696562
697563 // Labeled blocks (no conditional branch)
698564 case.addCompareOutput(
699 \\pub export fn _start() noreturn {
565 \\pub fn main() void {
700566 \\ assert(add(3, 4) == 20);
701 \\
702 \\ exit();
703567 \\}
704568 \\
705569 \\fn add(a: u32, b: u32) u32 {
......@@ -717,26 +581,14 @@ pub fn addCases(ctx: *TestContext) !void {
717581 \\pub fn assert(ok: bool) void {
718582 \\ if (!ok) unreachable; // assertion failure
719583 \\}
720 \\
721 \\fn exit() noreturn {
722 \\ asm volatile ("syscall"
723 \\ :
724 \\ : [number] "{rax}" (231),
725 \\ [arg1] "{rdi}" (0)
726 \\ : "rcx", "r11", "memory"
727 \\ );
728 \\ unreachable;
729 \\}
730584 ,
731585 "",
732586 );
733587
734588 // This catches a possible bug in the logic for re-using dying operands.
735589 case.addCompareOutput(
736 \\pub export fn _start() noreturn {
590 \\pub fn main() void {
737591 \\ assert(add(3, 4) == 116);
738 \\
739 \\ exit();
740592 \\}
741593 \\
742594 \\fn add(a: u32, b: u32) u32 {
......@@ -759,27 +611,15 @@ pub fn addCases(ctx: *TestContext) !void {
759611 \\pub fn assert(ok: bool) void {
760612 \\ if (!ok) unreachable; // assertion failure
761613 \\}
762 \\
763 \\fn exit() noreturn {
764 \\ asm volatile ("syscall"
765 \\ :
766 \\ : [number] "{rax}" (231),
767 \\ [arg1] "{rdi}" (0)
768 \\ : "rcx", "r11", "memory"
769 \\ );
770 \\ unreachable;
771 \\}
772614 ,
773615 "",
774616 );
775617
776618 // Spilling registers to the stack.
777619 case.addCompareOutput(
778 \\pub export fn _start() noreturn {
620 \\pub fn main() void {
779621 \\ assert(add(3, 4) == 1221);
780622 \\ assert(mul(3, 4) == 21609);
781 \\
782 \\ exit();
783623 \\}
784624 \\
785625 \\fn add(a: u32, b: u32) u32 {
......@@ -840,27 +680,15 @@ pub fn addCases(ctx: *TestContext) !void {
840680 \\pub fn assert(ok: bool) void {
841681 \\ if (!ok) unreachable; // assertion failure
842682 \\}
843 \\
844 \\fn exit() noreturn {
845 \\ asm volatile ("syscall"
846 \\ :
847 \\ : [number] "{rax}" (231),
848 \\ [arg1] "{rdi}" (0)
849 \\ : "rcx", "r11", "memory"
850 \\ );
851 \\ unreachable;
852 \\}
853683 ,
854684 "",
855685 );
856686
857687 // Reusing the registers of dead operands playing nicely with conditional branching.
858688 case.addCompareOutput(
859 \\pub export fn _start() noreturn {
689 \\pub fn main() void {
860690 \\ assert(add(3, 4) == 791);
861691 \\ assert(add(4, 3) == 79);
862 \\
863 \\ exit();
864692 \\}
865693 \\
866694 \\fn add(a: u32, b: u32) u32 {
......@@ -902,30 +730,18 @@ pub fn addCases(ctx: *TestContext) !void {
902730 \\pub fn assert(ok: bool) void {
903731 \\ if (!ok) unreachable; // assertion failure
904732 \\}
905 \\
906 \\fn exit() noreturn {
907 \\ asm volatile ("syscall"
908 \\ :
909 \\ : [number] "{rax}" (231),
910 \\ [arg1] "{rdi}" (0)
911 \\ : "rcx", "r11", "memory"
912 \\ );
913 \\ unreachable;
914 \\}
915733 ,
916734 "",
917735 );
918736
919737 // Character literals and multiline strings.
920738 case.addCompareOutput(
921 \\pub export fn _start() noreturn {
739 \\pub fn main() void {
922740 \\ const ignore =
923741 \\ \\ cool thx
924742 \\ \\
925743 \\ ;
926744 \\ add('ぁ', '\x03');
927 \\
928 \\ exit();
929745 \\}
930746 \\
931747 \\fn add(a: u32, b: u32) void {
......@@ -935,26 +751,14 @@ pub fn addCases(ctx: *TestContext) !void {
935751 \\pub fn assert(ok: bool) void {
936752 \\ if (!ok) unreachable; // assertion failure
937753 \\}
938 \\
939 \\fn exit() noreturn {
940 \\ asm volatile ("syscall"
941 \\ :
942 \\ : [number] "{rax}" (231),
943 \\ [arg1] "{rdi}" (0)
944 \\ : "rcx", "r11", "memory"
945 \\ );
946 \\ unreachable;
947 \\}
948754 ,
949755 "",
950756 );
951757
952758 // Global const.
953759 case.addCompareOutput(
954 \\pub export fn _start() noreturn {
760 \\pub fn main() void {
955761 \\ add(aa, bb);
956 \\
957 \\ exit();
958762 \\}
959763 \\
960764 \\const aa = 'ぁ';
......@@ -967,41 +771,19 @@ pub fn addCases(ctx: *TestContext) !void {
967771 \\pub fn assert(ok: bool) void {
968772 \\ if (!ok) unreachable; // assertion failure
969773 \\}
970 \\
971 \\fn exit() noreturn {
972 \\ asm volatile ("syscall"
973 \\ :
974 \\ : [number] "{rax}" (231),
975 \\ [arg1] "{rdi}" (0)
976 \\ : "rcx", "r11", "memory"
977 \\ );
978 \\ unreachable;
979 \\}
980774 ,
981775 "",
982776 );
983777
984778 // Array access.
985779 case.addCompareOutput(
986 \\pub export fn _start() noreturn {
780 \\pub fn main() void {
987781 \\ assert("hello"[0] == 'h');
988 \\
989 \\ exit();
990782 \\}
991783 \\
992784 \\pub fn assert(ok: bool) void {
993785 \\ if (!ok) unreachable; // assertion failure
994786 \\}
995 \\
996 \\fn exit() noreturn {
997 \\ asm volatile ("syscall"
998 \\ :
999 \\ : [number] "{rax}" (231),
1000 \\ [arg1] "{rdi}" (0)
1001 \\ : "rcx", "r11", "memory"
1002 \\ );
1003 \\ unreachable;
1004 \\}
1005787 ,
1006788 "",
1007789 );
......@@ -1009,61 +791,35 @@ pub fn addCases(ctx: *TestContext) !void {
1009791 // Array access to a global array.
1010792 case.addCompareOutput(
1011793 \\const hello = "hello".*;
1012 \\pub export fn _start() noreturn {
794 \\pub fn main() void {
1013795 \\ assert(hello[1] == 'e');
1014 \\
1015 \\ exit();
1016796 \\}
1017797 \\
1018798 \\pub fn assert(ok: bool) void {
1019799 \\ if (!ok) unreachable; // assertion failure
1020800 \\}
1021 \\
1022 \\fn exit() noreturn {
1023 \\ asm volatile ("syscall"
1024 \\ :
1025 \\ : [number] "{rax}" (231),
1026 \\ [arg1] "{rdi}" (0)
1027 \\ : "rcx", "r11", "memory"
1028 \\ );
1029 \\ unreachable;
1030 \\}
1031801 ,
1032802 "",
1033803 );
1034804
1035805 // 64bit set stack
1036806 case.addCompareOutput(
1037 \\pub export fn _start() noreturn {
807 \\pub fn main() void {
1038808 \\ var i: u64 = 0xFFEEDDCCBBAA9988;
1039809 \\ assert(i == 0xFFEEDDCCBBAA9988);
1040 \\
1041 \\ exit();
1042810 \\}
1043811 \\
1044812 \\pub fn assert(ok: bool) void {
1045813 \\ if (!ok) unreachable; // assertion failure
1046814 \\}
1047 \\
1048 \\fn exit() noreturn {
1049 \\ asm volatile ("syscall"
1050 \\ :
1051 \\ : [number] "{rax}" (231),
1052 \\ [arg1] "{rdi}" (0)
1053 \\ : "rcx", "r11", "memory"
1054 \\ );
1055 \\ unreachable;
1056 \\}
1057815 ,
1058816 "",
1059817 );
1060818
1061819 // Basic for loop
1062820 case.addCompareOutput(
1063 \\pub export fn _start() noreturn {
821 \\pub fn main() void {
1064822 \\ for ("hello") |_| print();
1065 \\
1066 \\ exit();
1067823 \\}
1068824 \\
1069825 \\fn print() void {
......@@ -1077,16 +833,6 @@ pub fn addCases(ctx: *TestContext) !void {
1077833 \\ );
1078834 \\ return;
1079835 \\}
1080 \\
1081 \\fn exit() noreturn {
1082 \\ asm volatile ("syscall"
1083 \\ :
1084 \\ : [number] "{rax}" (231),
1085 \\ [arg1] "{rdi}" (0)
1086 \\ : "rcx", "r11", "memory"
1087 \\ );
1088 \\ unreachable;
1089 \\}
1090836 ,
1091837 "hello\nhello\nhello\nhello\nhello\n",
1092838 );
......@@ -1095,19 +841,8 @@ pub fn addCases(ctx: *TestContext) !void {
1095841 {
1096842 var case = ctx.exe("basic import", linux_x64);
1097843 case.addCompareOutput(
1098 \\pub export fn _start() noreturn {
844 \\pub fn main() void {
1099845 \\ @import("print.zig").print();
1100 \\ exit();
1101 \\}
1102 \\
1103 \\fn exit() noreturn {
1104 \\ asm volatile ("syscall"
1105 \\ :
1106 \\ : [number] "{rax}" (231),
1107 \\ [arg1] "{rdi}" (@as(usize, 0))
1108 \\ : "rcx", "r11", "memory"
1109 \\ );
1110 \\ unreachable;
1111846 \\}
1112847 ,
1113848 "Hello, World!\n",
......@@ -1132,14 +867,14 @@ pub fn addCases(ctx: *TestContext) !void {
1132867 {
1133868 var case = ctx.exe("redundant comptime", linux_x64);
1134869 case.addError(
1135 \\pub export fn _start() void {
870 \\pub fn main() void {
1136871 \\ var a: comptime u32 = 0;
1137872 \\}
1138873 ,
1139874 &.{":2:12: error: redundant comptime keyword in already comptime scope"},
1140875 );
1141876 case.addError(
1142 \\pub export fn _start() void {
877 \\pub fn main() void {
1143878 \\ comptime {
1144879 \\ var a: u32 = comptime 0;
1145880 \\ }
......@@ -1151,19 +886,8 @@ pub fn addCases(ctx: *TestContext) !void {
1151886 {
1152887 var case = ctx.exe("import private", linux_x64);
1153888 case.addError(
1154 \\pub export fn _start() noreturn {
889 \\pub fn main() void {
1155890 \\ @import("print.zig").print();
1156 \\ exit();
1157 \\}
1158 \\
1159 \\fn exit() noreturn {
1160 \\ asm volatile ("syscall"
1161 \\ :
1162 \\ : [number] "{rax}" (231),
1163 \\ [arg1] "{rdi}" (@as(usize, 0))
1164 \\ : "rcx", "r11", "memory"
1165 \\ );
1166 \\ unreachable;
1167891 \\}
1168892 ,
1169893 &.{
......@@ -1215,19 +939,17 @@ pub fn addCases(ctx: *TestContext) !void {
1215939 });
1216940
1217941 ctx.compileError("compileError", linux_x64,
1218 \\pub export fn _start() noreturn {
942 \\export fn foo() void {
1219943 \\ @compileError("this is an error");
1220 \\ unreachable;
1221944 \\}
1222945 , &[_][]const u8{":2:3: error: this is an error"});
1223946
1224947 {
1225948 var case = ctx.obj("variable shadowing", linux_x64);
1226949 case.addError(
1227 \\export fn _start() noreturn {
950 \\pub fn main() void {
1228951 \\ var i: u32 = 10;
1229952 \\ var i: u32 = 10;
1230 \\ unreachable;
1231953 \\}
1232954 , &[_][]const u8{
1233955 ":3:9: error: redeclaration of 'i'",
......@@ -1235,9 +957,8 @@ pub fn addCases(ctx: *TestContext) !void {
1235957 });
1236958 case.addError(
1237959 \\var testing: i64 = 10;
1238 \\pub export fn _start() noreturn {
960 \\pub fn main() void {
1239961 \\ var testing: i64 = 20;
1240 \\ unreachable;
1241962 \\}
1242963 , &[_][]const u8{
1243964 ":3:9: error: local shadows declaration of 'testing'",
......@@ -1268,7 +989,7 @@ pub fn addCases(ctx: *TestContext) !void {
1268989
1269990 // Now only compile log statements remain. One per Decl.
1270991 case.addError(
1271 \\pub export fn _start() noreturn {
992 \\export fn _start() noreturn {
1272993 \\ const b = true;
1273994 \\ var f: u32 = 1;
1274995 \\ @compileLog(b, 20, f, x);
......@@ -1306,43 +1027,19 @@ pub fn addCases(ctx: *TestContext) !void {
13061027
13071028 // Break out of loop
13081029 case.addCompareOutput(
1309 \\pub export fn _start() noreturn {
1030 \\pub fn main() void {
13101031 \\ while (true) {
13111032 \\ break;
13121033 \\ }
1313 \\
1314 \\ exit();
1315 \\}
1316 \\
1317 \\fn exit() noreturn {
1318 \\ asm volatile ("syscall"
1319 \\ :
1320 \\ : [number] "{rax}" (231),
1321 \\ [arg1] "{rdi}" (0)
1322 \\ : "rcx", "r11", "memory"
1323 \\ );
1324 \\ unreachable;
13251034 \\}
13261035 ,
13271036 "",
13281037 );
13291038 case.addCompareOutput(
1330 \\pub export fn _start() noreturn {
1039 \\pub fn main() void {
13311040 \\ foo: while (true) {
13321041 \\ break :foo;
13331042 \\ }
1334 \\
1335 \\ exit();
1336 \\}
1337 \\
1338 \\fn exit() noreturn {
1339 \\ asm volatile ("syscall"
1340 \\ :
1341 \\ : [number] "{rax}" (231),
1342 \\ [arg1] "{rdi}" (0)
1343 \\ : "rcx", "r11", "memory"
1344 \\ );
1345 \\ unreachable;
13461043 \\}
13471044 ,
13481045 "",
......@@ -1534,46 +1231,26 @@ pub fn addCases(ctx: *TestContext) !void {
15341231 {
15351232 var case = ctx.exe("orelse at comptime", linux_x64);
15361233 case.addCompareOutput(
1537 \\pub export fn _start() noreturn {
1234 \\pub fn main() void {
15381235 \\ const i: ?u64 = 0;
1539 \\ const orelsed = i orelse 5;
1540 \\ assert(orelsed == 0);
1541 \\ exit();
1236 \\ const result = i orelse 5;
1237 \\ assert(result == 0);
15421238 \\}
15431239 \\fn assert(b: bool) void {
15441240 \\ if (!b) unreachable;
15451241 \\}
1546 \\fn exit() noreturn {
1547 \\ asm volatile ("syscall"
1548 \\ :
1549 \\ : [number] "{rax}" (231),
1550 \\ [arg1] "{rdi}" (0)
1551 \\ : "rcx", "r11", "memory"
1552 \\ );
1553 \\ unreachable;
1554 \\}
15551242 ,
15561243 "",
15571244 );
15581245 case.addCompareOutput(
1559 \\pub export fn _start() noreturn {
1246 \\pub fn main() void {
15601247 \\ const i: ?u64 = null;
1561 \\ const orelsed = i orelse 5;
1562 \\ assert(orelsed == 5);
1563 \\ exit();
1248 \\ const result = i orelse 5;
1249 \\ assert(result == 5);
15641250 \\}
15651251 \\fn assert(b: bool) void {
15661252 \\ if (!b) unreachable;
15671253 \\}
1568 \\fn exit() noreturn {
1569 \\ asm volatile ("syscall"
1570 \\ :
1571 \\ : [number] "{rax}" (231),
1572 \\ [arg1] "{rdi}" (0)
1573 \\ : "rcx", "r11", "memory"
1574 \\ );
1575 \\ unreachable;
1576 \\}
15771254 ,
15781255 "",
15791256 );
......@@ -1611,20 +1288,10 @@ pub fn addCases(ctx: *TestContext) !void {
16111288 {
16121289 var case = ctx.exe("passing u0 to function", linux_x64);
16131290 case.addCompareOutput(
1614 \\pub export fn _start() noreturn {
1291 \\pub fn main() void {
16151292 \\ doNothing(0);
1616 \\ exit();
16171293 \\}
16181294 \\fn doNothing(arg: u0) void {}
1619 \\fn exit() noreturn {
1620 \\ asm volatile ("syscall"
1621 \\ :
1622 \\ : [number] "{rax}" (231),
1623 \\ [arg1] "{rdi}" (0)
1624 \\ : "rcx", "r11", "memory"
1625 \\ );
1626 \\ unreachable;
1627 \\}
16281295 ,
16291296 "",
16301297 );
......@@ -1632,119 +1299,67 @@ pub fn addCases(ctx: *TestContext) !void {
16321299 {
16331300 var case = ctx.exe("catch at comptime", linux_x64);
16341301 case.addCompareOutput(
1635 \\pub export fn _start() noreturn {
1302 \\pub fn main() void {
16361303 \\ const i: anyerror!u64 = 0;
16371304 \\ const caught = i catch 5;
16381305 \\ assert(caught == 0);
1639 \\ exit();
16401306 \\}
16411307 \\fn assert(b: bool) void {
16421308 \\ if (!b) unreachable;
16431309 \\}
1644 \\fn exit() noreturn {
1645 \\ asm volatile ("syscall"
1646 \\ :
1647 \\ : [number] "{rax}" (231),
1648 \\ [arg1] "{rdi}" (0)
1649 \\ : "rcx", "r11", "memory"
1650 \\ );
1651 \\ unreachable;
1652 \\}
16531310 ,
16541311 "",
16551312 );
16561313
16571314 case.addCompareOutput(
1658 \\pub export fn _start() noreturn {
1315 \\pub fn main() void {
16591316 \\ const i: anyerror!u64 = error.B;
16601317 \\ const caught = i catch 5;
16611318 \\ assert(caught == 5);
1662 \\ exit();
16631319 \\}
16641320 \\fn assert(b: bool) void {
16651321 \\ if (!b) unreachable;
16661322 \\}
1667 \\fn exit() noreturn {
1668 \\ asm volatile ("syscall"
1669 \\ :
1670 \\ : [number] "{rax}" (231),
1671 \\ [arg1] "{rdi}" (0)
1672 \\ : "rcx", "r11", "memory"
1673 \\ );
1674 \\ unreachable;
1675 \\}
16761323 ,
16771324 "",
16781325 );
16791326
16801327 case.addCompareOutput(
1681 \\pub export fn _start() noreturn {
1328 \\pub fn main() void {
16821329 \\ const a: anyerror!comptime_int = 42;
16831330 \\ const b: *const comptime_int = &(a catch unreachable);
16841331 \\ assert(b.* == 42);
1685 \\
1686 \\ exit();
16871332 \\}
16881333 \\fn assert(b: bool) void {
16891334 \\ if (!b) unreachable; // assertion failure
16901335 \\}
1691 \\fn exit() noreturn {
1692 \\ asm volatile ("syscall"
1693 \\ :
1694 \\ : [number] "{rax}" (231),
1695 \\ [arg1] "{rdi}" (0)
1696 \\ : "rcx", "r11", "memory"
1697 \\ );
1698 \\ unreachable;
1699 \\}
17001336 , "");
17011337
17021338 case.addCompareOutput(
1703 \\pub export fn _start() noreturn {
1339 \\pub fn main() void {
17041340 \\ const a: anyerror!u32 = error.B;
17051341 \\ _ = &(a catch |err| assert(err == error.B));
1706 \\ exit();
17071342 \\}
17081343 \\fn assert(b: bool) void {
17091344 \\ if (!b) unreachable;
17101345 \\}
1711 \\fn exit() noreturn {
1712 \\ asm volatile ("syscall"
1713 \\ :
1714 \\ : [number] "{rax}" (231),
1715 \\ [arg1] "{rdi}" (0)
1716 \\ : "rcx", "r11", "memory"
1717 \\ );
1718 \\ unreachable;
1719 \\}
17201346 , "");
17211347
17221348 case.addCompareOutput(
1723 \\pub export fn _start() noreturn {
1349 \\pub fn main() void {
17241350 \\ const a: anyerror!u32 = error.Bar;
17251351 \\ a catch |err| assert(err == error.Bar);
1726 \\
1727 \\ exit();
17281352 \\}
17291353 \\fn assert(b: bool) void {
17301354 \\ if (!b) unreachable;
17311355 \\}
1732 \\fn exit() noreturn {
1733 \\ asm volatile ("syscall"
1734 \\ :
1735 \\ : [number] "{rax}" (231),
1736 \\ [arg1] "{rdi}" (0)
1737 \\ : "rcx", "r11", "memory"
1738 \\ );
1739 \\ unreachable;
1740 \\}
17411356 , "");
17421357 }
17431358 {
17441359 var case = ctx.exe("merge error sets", linux_x64);
17451360
17461361 case.addCompareOutput(
1747 \\pub export fn _start() noreturn {
1362 \\pub fn main() void {
17481363 \\ const E = error{ A, B, D } || error { A, B, C };
17491364 \\ const a = E.A;
17501365 \\ const b = E.B;
......@@ -1755,20 +1370,10 @@ pub fn addCases(ctx: *TestContext) !void {
17551370 \\ const y = E2.Y;
17561371 \\ const z = E2.Z;
17571372 \\ assert(anyerror || error { Z } == anyerror);
1758 \\ exit();
17591373 \\}
17601374 \\fn assert(b: bool) void {
17611375 \\ if (!b) unreachable;
17621376 \\}
1763 \\fn exit() noreturn {
1764 \\ asm volatile ("syscall"
1765 \\ :
1766 \\ : [number] "{rax}" (231),
1767 \\ [arg1] "{rdi}" (0)
1768 \\ : "rcx", "r11", "memory"
1769 \\ );
1770 \\ unreachable;
1771 \\}
17721377 ,
17731378 "",
17741379 );