Fix return type of Pointer.atUnboxedField tests (#361)

titzer · Feb 26, 2025 · b2ba936 · b2ba936
1 parent b43df73
commit b2ba936
Show file tree

Hide file tree

Showing 21 changed files with 57 additions and 130 deletions.
diff --git a/test/pointer/Pointer_atUnboxedField03.v3 b/test/pointer/Pointer_atUnboxedField03.v3
@@ -17,8 +17,7 @@ component Comp {
 	var compclsv = C.new(13, 14, 15);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var lclsv = C.new(17, 18, 19);
 
 	// check values before doing anything, using regular accesses

diff --git a/test/pointer/Pointer_atUnboxedField04.v3 b/test/pointer/Pointer_atUnboxedField04.v3
@@ -5,12 +5,10 @@ type V(v8: u8, v16: u16, v32: u32, v64: u64) #unboxed { }
 
 var gv = V(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using regular accesses
-
 	diff +=
 		(u32.view(gv.v8 ) ^ 1) +
 		(u32.view(gv.v16) ^ 2) +

diff --git a/test/pointer/Pointer_atUnboxedField05.v3 b/test/pointer/Pointer_atUnboxedField05.v3
@@ -7,12 +7,10 @@ component Comp {
 	var compv = V(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using regular accesses
-
 	diff +=
 		(u32.view(Comp.compv.v8 ) ^ 1) +
 		(u32.view(Comp.compv.v16) ^ 2) +

diff --git a/test/pointer/Pointer_atUnboxedField06.v3 b/test/pointer/Pointer_atUnboxedField06.v3
@@ -12,12 +12,10 @@ class C {
 
 var gclsv = C.new(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using regular accesses
-
 	diff +=
 		(u32.view(gclsv.clsv.v8 ) ^ 1) +
 		(u32.view(gclsv.clsv.v16) ^ 2) +

diff --git a/test/pointer/Pointer_atUnboxedField07.v3 b/test/pointer/Pointer_atUnboxedField07.v3
@@ -14,12 +14,10 @@ component Comp {
 	var compclsv = C.new(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using regular accesses
-
 	diff +=
 		(u32.view(Comp.compclsv.clsv.v8 ) ^ 1) +
 		(u32.view(Comp.compclsv.clsv.v16) ^ 2) +

diff --git a/test/pointer/Pointer_atUnboxedField08.v3 b/test/pointer/Pointer_atUnboxedField08.v3
@@ -10,14 +10,12 @@ class C {
 	}
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	var lclsv = C.new(1, 2, 3, 4);
 
 	// check values before doing anything, using regular accesses
-
 	diff +=
 		(u32.view(lclsv.clsv.v8 ) ^ 1) +
 		(u32.view(lclsv.clsv.v16) ^ 2) +

diff --git a/test/pointer/Pointer_atUnboxedField09.v3 b/test/pointer/Pointer_atUnboxedField09.v3
@@ -5,18 +5,16 @@ type V(v8: u8, v16: u16, v32: u32, v64: u64) #unboxed { }
 
 var gv = V(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using pointer loads
-
 	diff +=
 		(u32.view(Pointer.atField(gv.v8 ).load< u8>()) ^ 1) +
 		(u32.view(Pointer.atField(gv.v16).load<u16>()) ^ 2) +
 		(u32.view(Pointer.atField(gv.v32).load<u32>()) ^ 3);
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Pointer.atField(gv.v64).load<u64>()) ^ 4);
+
+	if (Pointer.SIZE == 8) diff += (u32.view(Pointer.atField(gv.v64).load<u64>()) ^ 4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField10.v3 b/test/pointer/Pointer_atUnboxedField10.v3
@@ -7,18 +7,16 @@ component Comp {
 	var compv = V(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using pointer loads
-
 	diff +=
 		(u32.view(Pointer.atField(Comp.compv.v8 ).load< u8>()) ^ 1) +
 		(u32.view(Pointer.atField(Comp.compv.v16).load<u16>()) ^ 2) +
 		(u32.view(Pointer.atField(Comp.compv.v32).load<u32>()) ^ 3);
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Pointer.atField(Comp.compv.v64).load<u64>()) ^ 4);
+
+	if (Pointer.SIZE == 8) diff += (u32.view(Pointer.atField(Comp.compv.v64).load<u64>()) ^ 4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField11.v3 b/test/pointer/Pointer_atUnboxedField11.v3
@@ -12,18 +12,15 @@ class C {
 
 var gclsv = C.new(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using pointer loads
-
 	diff +=
 		(u32.view(Pointer.atField(gclsv.clsv.v8 ).load< u8>()) ^ 1) +
 		(u32.view(Pointer.atField(gclsv.clsv.v16).load<u16>()) ^ 2) +
 		(u32.view(Pointer.atField(gclsv.clsv.v32).load<u32>()) ^ 3);
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Pointer.atField(gclsv.clsv.v64).load<u64>()) ^ 4);
+	if (Pointer.SIZE == 8) diff += (u32.view(Pointer.atField(gclsv.clsv.v64).load<u64>()) ^ 4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField12.v3 b/test/pointer/Pointer_atUnboxedField12.v3
@@ -14,8 +14,7 @@ component Comp {
 	var compclsv = C.new(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// check values before doing anything, using pointer loads
@@ -24,8 +23,7 @@ def main(arg: int) -> u64 {
 		(u32.view(Pointer.atField(Comp.compclsv.clsv.v8 ).load< u8>()) ^ 1) +
 		(u32.view(Pointer.atField(Comp.compclsv.clsv.v16).load<u16>()) ^ 2) +
 		(u32.view(Pointer.atField(Comp.compclsv.clsv.v32).load<u32>()) ^ 3);
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Pointer.atField(Comp.compclsv.clsv.v64).load<u64>()) ^ 4);
+	if (Pointer.SIZE == 8) diff += (u32.view(Pointer.atField(Comp.compclsv.clsv.v64).load<u64>()) ^ 4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField13.v3 b/test/pointer/Pointer_atUnboxedField13.v3
@@ -10,20 +10,17 @@ class C {
 	}
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	var lclsv = C.new(1, 2, 3, 4);
 
 	// check values before doing anything, using pointer loads
-
 	diff +=
 		(u32.view(Pointer.atField(lclsv.clsv.v8 ).load< u8>()) ^ 1) +
 		(u32.view(Pointer.atField(lclsv.clsv.v16).load<u16>()) ^ 2) +
 		(u32.view(Pointer.atField(lclsv.clsv.v32).load<u32>()) ^ 3);
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Pointer.atField(lclsv.clsv.v64).load<u64>()) ^ 4);
+	if (Pointer.SIZE == 8) diff += (u32.view(Pointer.atField(lclsv.clsv.v64).load<u64>()) ^ 4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField14.v3 b/test/pointer/Pointer_atUnboxedField14.v3
@@ -5,36 +5,30 @@ type V(v8: u8, v16: u16, v32: u32, v64: u64) #unboxed { }
 
 var gv = V(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// change values with cmpswp
-
 	Pointer.atField(gv.v8 ).cmpswp< u8>(1, u8 .!(101 + arg));
 	Pointer.atField(gv.v16).cmpswp<u16>(2, u16.!(102 + arg));
 	Pointer.atField(gv.v32).cmpswp<u32>(3, u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(gv.v64).cmpswp<u64>(4, u64.!(104 + arg));
+	if (Pointer.SIZE == 8) Pointer.atField(gv.v64).cmpswp<u64>(4, u64.!(104 + arg));
 
 	// check values after cmpswp, using regular accesses
-
 	diff +=
 		(u32.view(gv.v8 ) ^ u32.!(101 + arg)) +
 		(u32.view(gv.v16) ^ u32.!(102 + arg)) +
 		(u32.view(gv.v32) ^ u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(gv.v64) ^ u32.!(104 + arg));
+	if (Pointer.SIZE == 8) diff += (u32.view(gv.v64) ^ u32.!(104 + arg));
 
 	// reset values for succeeding runs
 	Pointer.atField(gv.v8 ).store< u8>(1);
 	Pointer.atField(gv.v16).store<u16>(2);
 	Pointer.atField(gv.v32).store<u32>(3);
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(gv.v64).store<u64>(4);
+	if (Pointer.SIZE == 8) Pointer.atField(gv.v64).store<u64>(4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField15.v3 b/test/pointer/Pointer_atUnboxedField15.v3
@@ -7,8 +7,7 @@ component Comp {
 	var compv = V(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// change values with cmpswp
@@ -17,8 +16,7 @@ def main(arg: int) -> u64 {
 	Pointer.atField(Comp.compv.v16).cmpswp<u16>(2, u16.!(102 + arg));
 	Pointer.atField(Comp.compv.v32).cmpswp<u32>(3, u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(Comp.compv.v64).cmpswp<u64>(4, u64.!(104 + arg));
+	if (Pointer.SIZE == 8) Pointer.atField(Comp.compv.v64).cmpswp<u64>(4, u64.!(104 + arg));
 
 	// check values after cmpswp, using regular accesses
 
@@ -27,16 +25,14 @@ def main(arg: int) -> u64 {
 		(u32.view(Comp.compv.v16) ^ u32.!(102 + arg)) +
 		(u32.view(Comp.compv.v32) ^ u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Comp.compv.v64) ^ u32.!(104 + arg));
+	if (Pointer.SIZE == 8) diff += (u32.view(Comp.compv.v64) ^ u32.!(104 + arg));
 
 	// reset values for succeeding runs
 	Pointer.atField(Comp.compv.v8 ).store< u8>(1);
 	Pointer.atField(Comp.compv.v16).store<u16>(2);
 	Pointer.atField(Comp.compv.v32).store<u32>(3);
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(Comp.compv.v64).store<u64>(4);
+	if (Pointer.SIZE == 8) Pointer.atField(Comp.compv.v64).store<u64>(4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField16.v3 b/test/pointer/Pointer_atUnboxedField16.v3
@@ -12,8 +12,7 @@ class C {
 
 var gclsv = C.new(1, 2, 3, 4);
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// change values with cmpswp
@@ -22,8 +21,7 @@ def main(arg: int) -> u64 {
 	Pointer.atField(gclsv.clsv.v16).cmpswp<u16>(2, u16.!(102 + arg));
 	Pointer.atField(gclsv.clsv.v32).cmpswp<u32>(3, u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(gclsv.clsv.v64).cmpswp<u64>(4, u64.!(104 + arg));
+	if (Pointer.SIZE == 8) Pointer.atField(gclsv.clsv.v64).cmpswp<u64>(4, u64.!(104 + arg));
 
 	// check values after cmpswp, using regular accesses
 
@@ -32,16 +30,14 @@ def main(arg: int) -> u64 {
 		(u32.view(gclsv.clsv.v16) ^ u32.!(102 + arg)) +
 		(u32.view(gclsv.clsv.v32) ^ u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(gclsv.clsv.v64) ^ u32.!(104 + arg));
+	if (Pointer.SIZE == 8) diff += (u32.view(gclsv.clsv.v64) ^ u32.!(104 + arg));
 
 	// reset values for succeeding runs
 	Pointer.atField(gclsv.clsv.v8 ).store< u8>(1);
 	Pointer.atField(gclsv.clsv.v16).store<u16>(2);
 	Pointer.atField(gclsv.clsv.v32).store<u32>(3);
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(gclsv.clsv.v64).store<u64>(4);
+	if (Pointer.SIZE == 8) Pointer.atField(gclsv.clsv.v64).store<u64>(4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField17.v3 b/test/pointer/Pointer_atUnboxedField17.v3
@@ -14,12 +14,10 @@ component Comp {
 	var compclsv = C.new(1, 2, 3, 4);
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	// change values with cmpswp
-
 	Pointer.atField(Comp.compclsv.clsv.v8 ).cmpswp< u8>(1, u8 .!(101 + arg));
 	Pointer.atField(Comp.compclsv.clsv.v16).cmpswp<u16>(2, u16.!(102 + arg));
 	Pointer.atField(Comp.compclsv.clsv.v32).cmpswp<u32>(3, u32.!(103 + arg));
@@ -28,22 +26,19 @@ def main(arg: int) -> u64 {
 		Pointer.atField(Comp.compclsv.clsv.v64).cmpswp<u64>(4, u64.!(104 + arg));
 
 	// check values after cmpswp, using regular accesses
-
 	diff +=
 		(u32.view(Comp.compclsv.clsv.v8 ) ^ u32.!(101 + arg)) +
 		(u32.view(Comp.compclsv.clsv.v16) ^ u32.!(102 + arg)) +
 		(u32.view(Comp.compclsv.clsv.v32) ^ u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(Comp.compclsv.clsv.v64) ^ u32.!(104 + arg));
+	if (Pointer.SIZE == 8) diff += (u32.view(Comp.compclsv.clsv.v64) ^ u32.!(104 + arg));
 
 	// reset values for succeeding runs
 	Pointer.atField(Comp.compclsv.clsv.v8 ).store< u8>(1);
 	Pointer.atField(Comp.compclsv.clsv.v16).store<u16>(2);
 	Pointer.atField(Comp.compclsv.clsv.v32).store<u32>(3);
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(Comp.compclsv.clsv.v64).store<u64>(4);
+	if (Pointer.SIZE == 8) Pointer.atField(Comp.compclsv.clsv.v64).store<u64>(4);
 
 	return diff;
 }
diff --git a/test/pointer/Pointer_atUnboxedField18.v3 b/test/pointer/Pointer_atUnboxedField18.v3
@@ -10,38 +10,32 @@ class C {
 	}
 }
 
-def main(arg: int) -> u64 {
-
+def main(arg: int) -> u32 {
 	var diff: u32 = 0;
 
 	var lclsv = C.new(1, 2, 3, 4);
 
 	// change values with cmpswp
-
 	Pointer.atField(lclsv.clsv.v8 ).cmpswp< u8>(1, u8 .!(101 + arg));
 	Pointer.atField(lclsv.clsv.v16).cmpswp<u16>(2, u16.!(102 + arg));
 	Pointer.atField(lclsv.clsv.v32).cmpswp<u32>(3, u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(lclsv.clsv.v64).cmpswp<u64>(4, u64.!(104 + arg));
+	if (Pointer.SIZE == 8) Pointer.atField(lclsv.clsv.v64).cmpswp<u64>(4, u64.!(104 + arg));
 
 	// check values after cmpswp, using regular accesses
-
 	diff +=
 		(u32.view(lclsv.clsv.v8 ) ^ u32.!(101 + arg)) +
 		(u32.view(lclsv.clsv.v16) ^ u32.!(102 + arg)) +
 		(u32.view(lclsv.clsv.v32) ^ u32.!(103 + arg));
 
-	if (Pointer.SIZE == 8)
-		diff += (u32.view(lclsv.clsv.v64) ^ u32.!(104 + arg));
+	if (Pointer.SIZE == 8) diff += (u32.view(lclsv.clsv.v64) ^ u32.!(104 + arg));
 
 	// reset values for succeeding runs
 	Pointer.atField(lclsv.clsv.v8 ).store< u8>(1);
 	Pointer.atField(lclsv.clsv.v16).store<u16>(2);
 	Pointer.atField(lclsv.clsv.v32).store<u32>(3);
 
-	if (Pointer.SIZE == 8)
-		Pointer.atField(lclsv.clsv.v64).store<u64>(4);
+	if (Pointer.SIZE == 8) Pointer.atField(lclsv.clsv.v64).store<u64>(4);
 
 	return diff;
 }