lang: Add u64 and i64 types
db9373cdbb409294c35ac0e51f6661d4c264061aff00f950318699692c8cbb8b
Add the 64-bit integer types to the scanner, parser, resolver and lowering, with 64-bit arithmetic, shifts, comparisons and casts. Integer literals stay 32-bit immediates that are sign-extended when widened, so a literal of a 64-bit type must fit in 31 bits (u64) or in the i32 range (i64). Wider values are built with shifts at run time. Assisted-by: Claude:opus-5.5
1 parent
a2300ff4
lib/std/arch/rv64/tests/arith.w64.rad
added
+255 -0
| 1 | + | //! Test 64-bit integer arithmetic. |
|
| 2 | + | //! Verifies that i64/u64 operations use full-width instructions |
|
| 3 | + | //! and that widening/narrowing casts work correctly. |
|
| 4 | + | ||
| 5 | + | fn testI64Add() -> bool { |
|
| 6 | + | let a: i64 = 100; |
|
| 7 | + | let b: i64 = 200; |
|
| 8 | + | let result: i64 = a + b; |
|
| 9 | + | if result != 300 { |
|
| 10 | + | return false; |
|
| 11 | + | } |
|
| 12 | + | return true; |
|
| 13 | + | } |
|
| 14 | + | ||
| 15 | + | fn testU64Add() -> bool { |
|
| 16 | + | let a: u64 = 100; |
|
| 17 | + | let b: u64 = 200; |
|
| 18 | + | let result: u64 = a + b; |
|
| 19 | + | if result != 300 { |
|
| 20 | + | return false; |
|
| 21 | + | } |
|
| 22 | + | return true; |
|
| 23 | + | } |
|
| 24 | + | ||
| 25 | + | fn testI64Sub() -> bool { |
|
| 26 | + | let a: i64 = 500; |
|
| 27 | + | let b: i64 = 300; |
|
| 28 | + | let result: i64 = a - b; |
|
| 29 | + | if result != 200 { |
|
| 30 | + | return false; |
|
| 31 | + | } |
|
| 32 | + | return true; |
|
| 33 | + | } |
|
| 34 | + | ||
| 35 | + | fn testI64Mul() -> bool { |
|
| 36 | + | let a: i64 = 1000; |
|
| 37 | + | let b: i64 = 2000; |
|
| 38 | + | let result: i64 = a * b; |
|
| 39 | + | if result != 2000000 { |
|
| 40 | + | return false; |
|
| 41 | + | } |
|
| 42 | + | return true; |
|
| 43 | + | } |
|
| 44 | + | ||
| 45 | + | fn testI64Div() -> bool { |
|
| 46 | + | let a: i64 = 1000; |
|
| 47 | + | let b: i64 = 10; |
|
| 48 | + | let result: i64 = a / b; |
|
| 49 | + | if result != 100 { |
|
| 50 | + | return false; |
|
| 51 | + | } |
|
| 52 | + | return true; |
|
| 53 | + | } |
|
| 54 | + | ||
| 55 | + | fn testU64Div() -> bool { |
|
| 56 | + | let a: u64 = 1000; |
|
| 57 | + | let b: u64 = 10; |
|
| 58 | + | let result: u64 = a / b; |
|
| 59 | + | if result != 100 { |
|
| 60 | + | return false; |
|
| 61 | + | } |
|
| 62 | + | return true; |
|
| 63 | + | } |
|
| 64 | + | ||
| 65 | + | fn testI64Neg() -> bool { |
|
| 66 | + | let a: i64 = 42; |
|
| 67 | + | let result: i64 = -a; |
|
| 68 | + | if result != -42 { |
|
| 69 | + | return false; |
|
| 70 | + | } |
|
| 71 | + | return true; |
|
| 72 | + | } |
|
| 73 | + | ||
| 74 | + | fn testI64Shift() -> bool { |
|
| 75 | + | let a: i64 = 1; |
|
| 76 | + | let result: i64 = a << 40; |
|
| 77 | + | if (result >> 20) != 1048576 { |
|
| 78 | + | return false; |
|
| 79 | + | } |
|
| 80 | + | let back: i64 = result >> 40; |
|
| 81 | + | if back != 1 { |
|
| 82 | + | return false; |
|
| 83 | + | } |
|
| 84 | + | return true; |
|
| 85 | + | } |
|
| 86 | + | ||
| 87 | + | fn testU64Shift() -> bool { |
|
| 88 | + | let a: u64 = 1; |
|
| 89 | + | let shifted: u64 = a << 32; |
|
| 90 | + | // Shift by 32 should NOT wrap like u32 would. |
|
| 91 | + | let back: u64 = shifted >> 32; |
|
| 92 | + | if back != 1 { |
|
| 93 | + | return false; |
|
| 94 | + | } |
|
| 95 | + | return true; |
|
| 96 | + | } |
|
| 97 | + | ||
| 98 | + | fn testI64Bitwise() -> bool { |
|
| 99 | + | let a: i64 = 0xFF00; |
|
| 100 | + | let b: i64 = 0x0FF0; |
|
| 101 | + | let andResult: i64 = a & b; |
|
| 102 | + | if andResult != 0x0F00 { |
|
| 103 | + | return false; |
|
| 104 | + | } |
|
| 105 | + | let orResult: i64 = a | b; |
|
| 106 | + | if orResult != 0xFFF0 { |
|
| 107 | + | return false; |
|
| 108 | + | } |
|
| 109 | + | let xorResult: i64 = a ^ b; |
|
| 110 | + | if xorResult != 0xF0F0 { |
|
| 111 | + | return false; |
|
| 112 | + | } |
|
| 113 | + | return true; |
|
| 114 | + | } |
|
| 115 | + | ||
| 116 | + | fn testWidenI32ToI64() -> bool { |
|
| 117 | + | let a: i32 = -42; |
|
| 118 | + | let b: i64 = a as i64; |
|
| 119 | + | if b != -42 { |
|
| 120 | + | return false; |
|
| 121 | + | } |
|
| 122 | + | return true; |
|
| 123 | + | } |
|
| 124 | + | ||
| 125 | + | fn testWidenU32ToU64() -> bool { |
|
| 126 | + | let a: u32 = 0xFFFFFFFF; |
|
| 127 | + | let b: u64 = a as u64; |
|
| 128 | + | // Should zero-extend, not sign-extend. |
|
| 129 | + | // If sign-extended, this would be a very large negative number in i64. |
|
| 130 | + | let c: u64 = b >> 32; |
|
| 131 | + | if c != 0 { |
|
| 132 | + | return false; |
|
| 133 | + | } |
|
| 134 | + | return true; |
|
| 135 | + | } |
|
| 136 | + | ||
| 137 | + | fn testNarrowI64ToI32() -> bool { |
|
| 138 | + | let a: i64 = 42; |
|
| 139 | + | let b: i32 = a as i32; |
|
| 140 | + | if b != 42 { |
|
| 141 | + | return false; |
|
| 142 | + | } |
|
| 143 | + | return true; |
|
| 144 | + | } |
|
| 145 | + | ||
| 146 | + | fn testNarrowU64ToU32() -> bool { |
|
| 147 | + | let a: u64 = 42; |
|
| 148 | + | let b: u32 = a as u32; |
|
| 149 | + | if b != 42 { |
|
| 150 | + | return false; |
|
| 151 | + | } |
|
| 152 | + | return true; |
|
| 153 | + | } |
|
| 154 | + | ||
| 155 | + | fn testI64Compare() -> bool { |
|
| 156 | + | let a: i64 = -1; |
|
| 157 | + | let b: i64 = 1; |
|
| 158 | + | if a >= b { |
|
| 159 | + | return false; |
|
| 160 | + | } |
|
| 161 | + | if b <= a { |
|
| 162 | + | return false; |
|
| 163 | + | } |
|
| 164 | + | return true; |
|
| 165 | + | } |
|
| 166 | + | ||
| 167 | + | fn testU64Compare() -> bool { |
|
| 168 | + | let a: u64 = 100; |
|
| 169 | + | let b: u64 = 200; |
|
| 170 | + | if a >= b { |
|
| 171 | + | return false; |
|
| 172 | + | } |
|
| 173 | + | if b <= a { |
|
| 174 | + | return false; |
|
| 175 | + | } |
|
| 176 | + | return true; |
|
| 177 | + | } |
|
| 178 | + | ||
| 179 | + | fn testI64Modulo() -> bool { |
|
| 180 | + | let a: i64 = 17; |
|
| 181 | + | let b: i64 = 5; |
|
| 182 | + | let result: i64 = a % b; |
|
| 183 | + | if result != 2 { |
|
| 184 | + | return false; |
|
| 185 | + | } |
|
| 186 | + | return true; |
|
| 187 | + | } |
|
| 188 | + | ||
| 189 | + | fn testU64Modulo() -> bool { |
|
| 190 | + | let a: u64 = 17; |
|
| 191 | + | let b: u64 = 5; |
|
| 192 | + | let result: u64 = a % b; |
|
| 193 | + | if result != 2 { |
|
| 194 | + | return false; |
|
| 195 | + | } |
|
| 196 | + | return true; |
|
| 197 | + | } |
|
| 198 | + | ||
| 199 | + | @default fn main() -> i32 { |
|
| 200 | + | if not testI64Add() { |
|
| 201 | + | return 1; |
|
| 202 | + | } |
|
| 203 | + | if not testU64Add() { |
|
| 204 | + | return 2; |
|
| 205 | + | } |
|
| 206 | + | if not testI64Sub() { |
|
| 207 | + | return 3; |
|
| 208 | + | } |
|
| 209 | + | if not testI64Mul() { |
|
| 210 | + | return 4; |
|
| 211 | + | } |
|
| 212 | + | if not testI64Div() { |
|
| 213 | + | return 5; |
|
| 214 | + | } |
|
| 215 | + | if not testU64Div() { |
|
| 216 | + | return 6; |
|
| 217 | + | } |
|
| 218 | + | if not testI64Neg() { |
|
| 219 | + | return 7; |
|
| 220 | + | } |
|
| 221 | + | if not testI64Shift() { |
|
| 222 | + | return 8; |
|
| 223 | + | } |
|
| 224 | + | if not testU64Shift() { |
|
| 225 | + | return 9; |
|
| 226 | + | } |
|
| 227 | + | if not testI64Bitwise() { |
|
| 228 | + | return 10; |
|
| 229 | + | } |
|
| 230 | + | if not testWidenI32ToI64() { |
|
| 231 | + | return 11; |
|
| 232 | + | } |
|
| 233 | + | if not testWidenU32ToU64() { |
|
| 234 | + | return 12; |
|
| 235 | + | } |
|
| 236 | + | if not testNarrowI64ToI32() { |
|
| 237 | + | return 13; |
|
| 238 | + | } |
|
| 239 | + | if not testNarrowU64ToU32() { |
|
| 240 | + | return 14; |
|
| 241 | + | } |
|
| 242 | + | if not testI64Compare() { |
|
| 243 | + | return 15; |
|
| 244 | + | } |
|
| 245 | + | if not testU64Compare() { |
|
| 246 | + | return 16; |
|
| 247 | + | } |
|
| 248 | + | if not testI64Modulo() { |
|
| 249 | + | return 17; |
|
| 250 | + | } |
|
| 251 | + | if not testU64Modulo() { |
|
| 252 | + | return 18; |
|
| 253 | + | } |
|
| 254 | + | return 0; |
|
| 255 | + | } |
lib/std/lang/lower.rad
+4 -2
| 5505 | 5505 | } |
|
| 5506 | 5506 | ||
| 5507 | 5507 | /// Check whether a resolver type is a signed integer type. |
|
| 5508 | 5508 | fn isSignedType(t: resolver::Type) -> bool { |
|
| 5509 | 5509 | match t { |
|
| 5510 | - | case resolver::Type::I8, resolver::Type::I16, resolver::Type::I32 => return true, |
|
| 5510 | + | case resolver::Type::I8, resolver::Type::I16, resolver::Type::I32, resolver::Type::I64 => return true, |
|
| 5511 | 5511 | else => return false, |
|
| 5512 | 5512 | } |
|
| 5513 | 5513 | } |
|
| 5514 | 5514 | ||
| 5515 | 5515 | /// Check whether a resolver type is an unsigned integer type. |
|
| 5516 | 5516 | fn isUnsignedType(t: resolver::Type) -> bool { |
|
| 5517 | 5517 | match t { |
|
| 5518 | - | case resolver::Type::U8, resolver::Type::U16, resolver::Type::U32 => return true, |
|
| 5518 | + | case resolver::Type::U8, resolver::Type::U16, resolver::Type::U32, resolver::Type::U64 => return true, |
|
| 5519 | 5519 | else => return false, |
|
| 5520 | 5520 | } |
|
| 5521 | 5521 | } |
|
| 5522 | 5522 | ||
| 5523 | 5523 | /// Lower a string literal to a slice value. |
| 6192 | 6192 | case resolver::Type::I16 => return il::Type::W16, |
|
| 6193 | 6193 | case resolver::Type::I32 => return il::Type::W32, |
|
| 6194 | 6194 | case resolver::Type::U8 => return il::Type::W8, |
|
| 6195 | 6195 | case resolver::Type::U16 => return il::Type::W16, |
|
| 6196 | 6196 | case resolver::Type::U32 => return il::Type::W32, |
|
| 6197 | + | case resolver::Type::I64 => return il::Type::W64, |
|
| 6198 | + | case resolver::Type::U64 => return il::Type::W64, |
|
| 6197 | 6199 | // Reference types are all pointer-sized (64-bit on RV64). |
|
| 6198 | 6200 | case resolver::Type::Pointer { .. } => return il::Type::W64, |
|
| 6199 | 6201 | // Aggregates are represented as pointers to stack memory. |
|
| 6200 | 6202 | case resolver::Type::Slice { .. } => return il::Type::W64, |
|
| 6201 | 6203 | case resolver::Type::Array(_) => return il::Type::W64, |
lib/std/lang/lower/tests/arith.w64.rad
added
+69 -0
| 1 | + | /// Add two i64 values. |
|
| 2 | + | fn addI64(a: i64, b: i64) -> i64 { |
|
| 3 | + | return a + b; |
|
| 4 | + | } |
|
| 5 | + | ||
| 6 | + | /// Subtract two i64 values. |
|
| 7 | + | fn subI64(a: i64, b: i64) -> i64 { |
|
| 8 | + | return a - b; |
|
| 9 | + | } |
|
| 10 | + | ||
| 11 | + | /// Multiply two i64 values. |
|
| 12 | + | fn mulI64(a: i64, b: i64) -> i64 { |
|
| 13 | + | return a * b; |
|
| 14 | + | } |
|
| 15 | + | ||
| 16 | + | /// Add two u64 values. |
|
| 17 | + | fn addU64(a: u64, b: u64) -> u64 { |
|
| 18 | + | return a + b; |
|
| 19 | + | } |
|
| 20 | + | ||
| 21 | + | /// Subtract two u64 values. |
|
| 22 | + | fn subU64(a: u64, b: u64) -> u64 { |
|
| 23 | + | return a - b; |
|
| 24 | + | } |
|
| 25 | + | ||
| 26 | + | /// Multiply two u64 values. |
|
| 27 | + | fn mulU64(a: u64, b: u64) -> u64 { |
|
| 28 | + | return a * b; |
|
| 29 | + | } |
|
| 30 | + | ||
| 31 | + | /// Left-shift u64. |
|
| 32 | + | fn shlU64(a: u64, b: u64) -> u64 { |
|
| 33 | + | return a << b; |
|
| 34 | + | } |
|
| 35 | + | ||
| 36 | + | /// Right-shift i64 (arithmetic). |
|
| 37 | + | fn shrI64(a: i64, b: i64) -> i64 { |
|
| 38 | + | return a >> b; |
|
| 39 | + | } |
|
| 40 | + | ||
| 41 | + | /// Divide i64 values. |
|
| 42 | + | fn divI64(a: i64, b: i64) -> i64 { |
|
| 43 | + | return a / b; |
|
| 44 | + | } |
|
| 45 | + | ||
| 46 | + | /// Divide u64 values. |
|
| 47 | + | fn divU64(a: u64, b: u64) -> u64 { |
|
| 48 | + | return a / b; |
|
| 49 | + | } |
|
| 50 | + | ||
| 51 | + | /// Widen i32 to i64. |
|
| 52 | + | fn widenI32ToI64(a: i32) -> i64 { |
|
| 53 | + | return a as i64; |
|
| 54 | + | } |
|
| 55 | + | ||
| 56 | + | /// Widen u32 to u64. |
|
| 57 | + | fn widenU32ToU64(a: u32) -> u64 { |
|
| 58 | + | return a as u64; |
|
| 59 | + | } |
|
| 60 | + | ||
| 61 | + | /// Narrow i64 to i32. |
|
| 62 | + | fn narrowI64ToI32(a: i64) -> i32 { |
|
| 63 | + | return a as i32; |
|
| 64 | + | } |
|
| 65 | + | ||
| 66 | + | /// Narrow u64 to u32. |
|
| 67 | + | fn narrowU64ToU32(a: u64) -> u32 { |
|
| 68 | + | return a as u32; |
|
| 69 | + | } |
lib/std/lang/lower/tests/arith.w64.ril
added
+83 -0
| 1 | + | fn w64 $addI64(w64 %0, w64 %1) { |
|
| 2 | + | @entry0 |
|
| 3 | + | add w64 %2 %0 %1; |
|
| 4 | + | ret %2; |
|
| 5 | + | } |
|
| 6 | + | ||
| 7 | + | fn w64 $subI64(w64 %0, w64 %1) { |
|
| 8 | + | @entry0 |
|
| 9 | + | sub w64 %2 %0 %1; |
|
| 10 | + | ret %2; |
|
| 11 | + | } |
|
| 12 | + | ||
| 13 | + | fn w64 $mulI64(w64 %0, w64 %1) { |
|
| 14 | + | @entry0 |
|
| 15 | + | mul w64 %2 %0 %1; |
|
| 16 | + | ret %2; |
|
| 17 | + | } |
|
| 18 | + | ||
| 19 | + | fn w64 $addU64(w64 %0, w64 %1) { |
|
| 20 | + | @entry0 |
|
| 21 | + | add w64 %2 %0 %1; |
|
| 22 | + | ret %2; |
|
| 23 | + | } |
|
| 24 | + | ||
| 25 | + | fn w64 $subU64(w64 %0, w64 %1) { |
|
| 26 | + | @entry0 |
|
| 27 | + | sub w64 %2 %0 %1; |
|
| 28 | + | ret %2; |
|
| 29 | + | } |
|
| 30 | + | ||
| 31 | + | fn w64 $mulU64(w64 %0, w64 %1) { |
|
| 32 | + | @entry0 |
|
| 33 | + | mul w64 %2 %0 %1; |
|
| 34 | + | ret %2; |
|
| 35 | + | } |
|
| 36 | + | ||
| 37 | + | fn w64 $shlU64(w64 %0, w64 %1) { |
|
| 38 | + | @entry0 |
|
| 39 | + | shl w64 %2 %0 %1; |
|
| 40 | + | ret %2; |
|
| 41 | + | } |
|
| 42 | + | ||
| 43 | + | fn w64 $shrI64(w64 %0, w64 %1) { |
|
| 44 | + | @entry0 |
|
| 45 | + | sshr w64 %2 %0 %1; |
|
| 46 | + | ret %2; |
|
| 47 | + | } |
|
| 48 | + | ||
| 49 | + | fn w64 $divI64(w64 %0, w64 %1) { |
|
| 50 | + | @entry0 |
|
| 51 | + | sdiv w64 %2 %0 %1; |
|
| 52 | + | ret %2; |
|
| 53 | + | } |
|
| 54 | + | ||
| 55 | + | fn w64 $divU64(w64 %0, w64 %1) { |
|
| 56 | + | @entry0 |
|
| 57 | + | udiv w64 %2 %0 %1; |
|
| 58 | + | ret %2; |
|
| 59 | + | } |
|
| 60 | + | ||
| 61 | + | fn w64 $widenI32ToI64(w32 %0) { |
|
| 62 | + | @entry0 |
|
| 63 | + | sext w32 %1 %0; |
|
| 64 | + | ret %1; |
|
| 65 | + | } |
|
| 66 | + | ||
| 67 | + | fn w64 $widenU32ToU64(w32 %0) { |
|
| 68 | + | @entry0 |
|
| 69 | + | zext w32 %1 %0; |
|
| 70 | + | ret %1; |
|
| 71 | + | } |
|
| 72 | + | ||
| 73 | + | fn w32 $narrowI64ToI32(w64 %0) { |
|
| 74 | + | @entry0 |
|
| 75 | + | sext w32 %1 %0; |
|
| 76 | + | ret %1; |
|
| 77 | + | } |
|
| 78 | + | ||
| 79 | + | fn w32 $narrowU64ToU32(w64 %0) { |
|
| 80 | + | @entry0 |
|
| 81 | + | zext w32 %1 %0; |
|
| 82 | + | ret %1; |
|
| 83 | + | } |
lib/std/lang/parser.rad
+8 -0
| 1974 | 1974 | } |
|
| 1975 | 1975 | case scanner::TokenKind::U32 => { |
|
| 1976 | 1976 | advance(p); |
|
| 1977 | 1977 | return nodeTypeInt(p, 4, ast::Signedness::Unsigned); |
|
| 1978 | 1978 | } |
|
| 1979 | + | case scanner::TokenKind::U64 => { |
|
| 1980 | + | advance(p); |
|
| 1981 | + | return nodeTypeInt(p, 8, ast::Signedness::Unsigned); |
|
| 1982 | + | } |
|
| 1979 | 1983 | case scanner::TokenKind::I8 => { |
|
| 1980 | 1984 | advance(p); |
|
| 1981 | 1985 | return nodeTypeInt(p, 1, ast::Signedness::Signed); |
|
| 1982 | 1986 | } |
|
| 1983 | 1987 | case scanner::TokenKind::I16 => { |
| 1986 | 1990 | } |
|
| 1987 | 1991 | case scanner::TokenKind::I32 => { |
|
| 1988 | 1992 | advance(p); |
|
| 1989 | 1993 | return nodeTypeInt(p, 4, ast::Signedness::Signed); |
|
| 1990 | 1994 | } |
|
| 1995 | + | case scanner::TokenKind::I64 => { |
|
| 1996 | + | advance(p); |
|
| 1997 | + | return nodeTypeInt(p, 8, ast::Signedness::Signed); |
|
| 1998 | + | } |
|
| 1991 | 1999 | case scanner::TokenKind::Bool => { |
|
| 1992 | 2000 | advance(p); |
|
| 1993 | 2001 | return node(p, ast::NodeValue::TypeSig(ast::TypeSig::Bool)); |
|
| 1994 | 2002 | } |
|
| 1995 | 2003 | case scanner::TokenKind::Void => { |
lib/std/lang/resolver.rad
+21 -3
| 199 | 199 | /// Types only used during inference. |
|
| 200 | 200 | Nil, Undefined, Int, |
|
| 201 | 201 | /// Primitive types. |
|
| 202 | 202 | Void, Opaque, Never, Bool, |
|
| 203 | 203 | /// Integer types. |
|
| 204 | - | U8, U16, U32, I8, I16, I32, |
|
| 204 | + | U8, U16, U32, U64, I8, I16, I32, I64, |
|
| 205 | 205 | /// Range types, eg. `start..end`. |
|
| 206 | 206 | Range { |
|
| 207 | 207 | start: ?*Type, |
|
| 208 | 208 | end: ?*Type, |
|
| 209 | 209 | }, |
| 1224 | 1224 | } |
|
| 1225 | 1225 | ||
| 1226 | 1226 | /// Check if a type is a numeric type. |
|
| 1227 | 1227 | fn isNumericType(ty: Type) -> bool { |
|
| 1228 | 1228 | match ty { |
|
| 1229 | - | case Type::U8, Type::U16, Type::U32, |
|
| 1230 | - | Type::I8, Type::I16, Type::I32, |
|
| 1229 | + | case Type::U8, Type::U16, Type::U32, Type::U64, |
|
| 1230 | + | Type::I8, Type::I16, Type::I32, Type::I64, |
|
| 1231 | 1231 | Type::Int => return true, |
|
| 1232 | 1232 | else => return false, |
|
| 1233 | 1233 | } |
|
| 1234 | 1234 | } |
|
| 1235 | 1235 |
| 1248 | 1248 | case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 }, |
|
| 1249 | 1249 | case Type::Bool => return Layout { size: 1, alignment: 1 }, |
|
| 1250 | 1250 | case Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 }, |
|
| 1251 | 1251 | case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 }, |
|
| 1252 | 1252 | case Type::U32, Type::I32, Type::Int => return Layout { size: 4, alignment: 4 }, |
|
| 1253 | + | case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 }, |
|
| 1253 | 1254 | case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE }, |
|
| 1254 | 1255 | case Type::Slice { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE }, |
|
| 1255 | 1256 | case Type::Array(arr) => return getArrayLayout(arr), |
|
| 1256 | 1257 | case Type::Optional(inner) => return getOptionalLayout(*inner), |
|
| 1257 | 1258 | case Type::Nominal(info) => return getNominalLayout(*info), |
| 1401 | 1402 | bits: 32, |
|
| 1402 | 1403 | min: I32_MIN, |
|
| 1403 | 1404 | max: I32_MAX, |
|
| 1404 | 1405 | lim: (I32_MAX as u32) + 1, |
|
| 1405 | 1406 | }, |
|
| 1407 | + | // Immediates are 32-bit here and sign-extended when widened, so only |
|
| 1408 | + | // the `i32` subset of the `i64` range is representable. |
|
| 1409 | + | case Type::I64 => return IntegerRange::Signed { |
|
| 1410 | + | bits: 64, |
|
| 1411 | + | min: I32_MIN, |
|
| 1412 | + | max: I32_MAX, |
|
| 1413 | + | lim: (I32_MAX as u32) + 1, |
|
| 1414 | + | }, |
|
| 1406 | 1415 | case Type::Int => return IntegerRange::Signed { |
|
| 1407 | 1416 | bits: 32, |
|
| 1408 | 1417 | min: I32_MIN, |
|
| 1409 | 1418 | max: I32_MAX, |
|
| 1410 | 1419 | lim: (I32_MAX as u32) + 1, |
|
| 1411 | 1420 | }, |
|
| 1412 | 1421 | case Type::U8 => return IntegerRange::Unsigned { bits: 8, max: U8_MAX }, |
|
| 1413 | 1422 | case Type::U16 => return IntegerRange::Unsigned { bits: 16, max: U16_MAX }, |
|
| 1414 | 1423 | case Type::U32 => return IntegerRange::Unsigned { bits: 32, max: parser::U32_MAX }, |
|
| 1424 | + | // Likewise, only values below `2^31` survive sign-extension intact. |
|
| 1425 | + | case Type::U64 => return IntegerRange::Unsigned { bits: 64, max: I32_MAX as u32 }, |
|
| 1415 | 1426 | else => return nil, |
|
| 1416 | 1427 | } |
|
| 1417 | 1428 | } |
|
| 1418 | 1429 | ||
| 1419 | 1430 | /// Validate that an integer constant fits within the target type's range. |
| 5207 | 5218 | return Type::U32; |
|
| 5208 | 5219 | } else { |
|
| 5209 | 5220 | return Type::I32; |
|
| 5210 | 5221 | } |
|
| 5211 | 5222 | } |
|
| 5223 | + | case 8 => { |
|
| 5224 | + | if sign == ast::Signedness::Unsigned { |
|
| 5225 | + | return Type::U64; |
|
| 5226 | + | } else { |
|
| 5227 | + | return Type::I64; |
|
| 5228 | + | } |
|
| 5229 | + | } |
|
| 5212 | 5230 | else => { |
|
| 5213 | 5231 | panic "resolveTypeSig: invalid integer width"; |
|
| 5214 | 5232 | } |
|
| 5215 | 5233 | } |
|
| 5216 | 5234 | } |
lib/std/lang/resolver/printer.rad
+6 -0
| 66 | 66 | io::print("u16"); |
|
| 67 | 67 | } |
|
| 68 | 68 | case super::Type::U32 => { |
|
| 69 | 69 | io::print("u32"); |
|
| 70 | 70 | } |
|
| 71 | + | case super::Type::U64 => { |
|
| 72 | + | io::print("u64"); |
|
| 73 | + | } |
|
| 71 | 74 | case super::Type::I8 => { |
|
| 72 | 75 | io::print("i8"); |
|
| 73 | 76 | } |
|
| 74 | 77 | case super::Type::I16 => { |
|
| 75 | 78 | io::print("i16"); |
|
| 76 | 79 | } |
|
| 77 | 80 | case super::Type::I32 => { |
|
| 78 | 81 | io::print("i32"); |
|
| 79 | 82 | } |
|
| 83 | + | case super::Type::I64 => { |
|
| 84 | + | io::print("i64"); |
|
| 85 | + | } |
|
| 80 | 86 | case super::Type::Pointer { target, mutable } => { |
|
| 81 | 87 | io::print("*"); |
|
| 82 | 88 | if mutable { |
|
| 83 | 89 | io::print("mut "); |
|
| 84 | 90 | } |
lib/std/lang/scanner.rad
+6 -2
| 101 | 101 | ||
| 102 | 102 | // Type or function attributes. |
|
| 103 | 103 | Pub, Extern, Static, |
|
| 104 | 104 | ||
| 105 | 105 | // Type-related tokens. |
|
| 106 | - | I8, I16, I32, U8, U16, U32, |
|
| 106 | + | I8, I16, I32, I64, U8, U16, U32, U64, |
|
| 107 | 107 | Void, Opaque, Fn, Bool, Union, Record, As |
|
| 108 | 108 | } |
|
| 109 | 109 | ||
| 110 | 110 | /// Convert a token kind to its string representation. |
|
| 111 | 111 | pub fn tokenKindToString(kind: TokenKind) -> *[u8] { |
| 198 | 198 | case TokenKind::Extern => return "Extern", |
|
| 199 | 199 | case TokenKind::Static => return "Static", |
|
| 200 | 200 | case TokenKind::I8 => return "I8", |
|
| 201 | 201 | case TokenKind::I16 => return "I16", |
|
| 202 | 202 | case TokenKind::I32 => return "I32", |
|
| 203 | + | case TokenKind::I64 => return "I64", |
|
| 203 | 204 | case TokenKind::U8 => return "U8", |
|
| 204 | 205 | case TokenKind::U16 => return "U16", |
|
| 205 | 206 | case TokenKind::U32 => return "U32", |
|
| 207 | + | case TokenKind::U64 => return "U64", |
|
| 206 | 208 | case TokenKind::Void => return "Void", |
|
| 207 | 209 | case TokenKind::Opaque => return "Opaque", |
|
| 208 | 210 | case TokenKind::Fn => return "Fn", |
|
| 209 | 211 | case TokenKind::Bool => return "Bool", |
|
| 210 | 212 | case TokenKind::Union => return "Union", |
| 220 | 222 | /// Corresponding token. |
|
| 221 | 223 | tok: TokenKind, |
|
| 222 | 224 | } |
|
| 223 | 225 | ||
| 224 | 226 | /// Sorted keyword table for binary search. |
|
| 225 | - | const KEYWORDS: [Keyword; 47] = [ |
|
| 227 | + | const KEYWORDS: [Keyword; 49] = [ |
|
| 226 | 228 | { name: "align", tok: TokenKind::Align }, |
|
| 227 | 229 | { name: "and", tok: TokenKind::And }, |
|
| 228 | 230 | { name: "as", tok: TokenKind::As }, |
|
| 229 | 231 | { name: "bool", tok: TokenKind::Bool }, |
|
| 230 | 232 | { name: "break", tok: TokenKind::Break }, |
| 237 | 239 | { name: "false", tok: TokenKind::False }, |
|
| 238 | 240 | { name: "fn", tok: TokenKind::Fn }, |
|
| 239 | 241 | { name: "for", tok: TokenKind::For }, |
|
| 240 | 242 | { name: "i16", tok: TokenKind::I16 }, |
|
| 241 | 243 | { name: "i32", tok: TokenKind::I32 }, |
|
| 244 | + | { name: "i64", tok: TokenKind::I64 }, |
|
| 242 | 245 | { name: "i8", tok: TokenKind::I8 }, |
|
| 243 | 246 | { name: "if", tok: TokenKind::If }, |
|
| 244 | 247 | { name: "in", tok: TokenKind::In }, |
|
| 245 | 248 | { name: "let", tok: TokenKind::Let }, |
|
| 246 | 249 | { name: "log", tok: TokenKind::Log }, |
| 262 | 265 | { name: "throws", tok: TokenKind::Throws }, |
|
| 263 | 266 | { name: "true", tok: TokenKind::True }, |
|
| 264 | 267 | { name: "try", tok: TokenKind::Try }, |
|
| 265 | 268 | { name: "u16", tok: TokenKind::U16 }, |
|
| 266 | 269 | { name: "u32", tok: TokenKind::U32 }, |
|
| 270 | + | { name: "u64", tok: TokenKind::U64 }, |
|
| 267 | 271 | { name: "u8", tok: TokenKind::U8 }, |
|
| 268 | 272 | { name: "undefined", tok: TokenKind::Undefined }, |
|
| 269 | 273 | { name: "union", tok: TokenKind::Union }, |
|
| 270 | 274 | { name: "use", tok: TokenKind::Use }, |
|
| 271 | 275 | { name: "void", tok: TokenKind::Void }, |
vim/radiance.vim
+1 -1
| 17 | 17 | " Keywords |
|
| 18 | 18 | syntax keyword radianceKeyword mod fn return if else while true false and or not case align static |
|
| 19 | 19 | syntax keyword radianceKeyword pub extern break continue use loop in for match nil undefined |
|
| 20 | 20 | syntax keyword radianceKeyword let mut as register device const log record union |
|
| 21 | 21 | syntax keyword radianceKeyword throws throw try catch panic super |
|
| 22 | - | syntax keyword radianceType i8 i16 i32 u8 u16 u32 f32 void bool bit opaque |
|
| 22 | + | syntax keyword radianceType i8 i16 i32 i64 u8 u16 u32 u64 f32 void bool bit opaque |
|
| 23 | 23 | ||
| 24 | 24 | " Double-quoted strings |
|
| 25 | 25 | syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape |
|
| 26 | 26 | " Characters |
|
| 27 | 27 | syntax region radianceCharacter start=/'/ skip=/\\'|\\\\/ end=/'/ oneline contains=radianceEscape |