diff --git a/src/check_expr.cpp b/src/check_expr.cpp index d31874959..8e09c0320 100644 --- a/src/check_expr.cpp +++ b/src/check_expr.cpp @@ -3407,7 +3407,7 @@ ExactValue get_constant_field(CheckerContext *c, Operand const *operand, Selecti return value; } else if (value.kind == ExactValue_Quaternion) { // @QuaternionLayout - Quaternion256 q = value.value_quaternion; + Quaternion256 q = *value.value_quaternion; GB_ASSERT(sel.index.count == 1); switch (sel.index[0]) { @@ -3432,7 +3432,7 @@ ExactValue get_constant_field(CheckerContext *c, Operand const *operand, Selecti return empty_exact_value; } else if (value.kind == ExactValue_Complex) { // @QuaternionLayout - Complex128 c = value.value_complex; + Complex128 c = *value.value_complex; GB_ASSERT(sel.index.count == 1); switch (sel.index[0]) { @@ -4727,8 +4727,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 if (is_type_complex(x->type)) { if (x->mode == Addressing_Constant) { ExactValue v = exact_value_to_complex(x->value); - f64 r = v.value_complex.real; - f64 i = -v.value_complex.imag; + f64 r = v.value_complex->real; + f64 i = -v.value_complex->imag; x->value = exact_value_complex(r, i); x->mode = Addressing_Constant; } else { @@ -4737,10 +4737,10 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 } else if (is_type_quaternion(x->type)) { if (x->mode == Addressing_Constant) { ExactValue v = exact_value_to_quaternion(x->value); - f64 r = v.value_quaternion.real; - f64 i = -v.value_quaternion.imag; - f64 j = -v.value_quaternion.jmag; - f64 k = -v.value_quaternion.kmag; + f64 r = +v.value_quaternion->real; + f64 i = -v.value_quaternion->imag; + f64 j = -v.value_quaternion->jmag; + f64 k = -v.value_quaternion->kmag; x->value = exact_value_quaternion(r, i, j, k); x->mode = Addressing_Constant; } else { @@ -5157,8 +5157,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32 operand->value.value_float = gb_abs(operand->value.value_float); break; case ExactValue_Complex: { - f64 r = operand->value.value_complex.real; - f64 i = operand->value.value_complex.imag; + f64 r = operand->value.value_complex->real; + f64 i = operand->value.value_complex->imag; operand->value = exact_value_float(gb_sqrt(r*r + i*i)); break; diff --git a/src/exact_value.cpp b/src/exact_value.cpp index 7199a28ac..326f4d587 100644 --- a/src/exact_value.cpp +++ b/src/exact_value.cpp @@ -46,16 +46,16 @@ enum ExactValueKind { struct ExactValue { ExactValueKind kind; union { - bool value_bool; - String value_string; - BigInt value_integer; // NOTE(bill): This must be an integer and not a pointer - f64 value_float; - i64 value_pointer; - Complex128 value_complex; - Quaternion256 value_quaternion; - Ast * value_compound; - Ast * value_procedure; - Type * value_typeid; + bool value_bool; + String value_string; + BigInt value_integer; // NOTE(bill): This must be an integer and not a pointer + f64 value_float; + i64 value_pointer; + Complex128 *value_complex; + Quaternion256 *value_quaternion; + Ast * value_compound; + Ast * value_procedure; + Type * value_typeid; }; }; @@ -85,9 +85,9 @@ HashKey hash_exact_value(ExactValue v) { case ExactValue_Pointer: return hash_integer(v.value_pointer); case ExactValue_Complex: - return hashing_proc(&v.value_complex, gb_size_of(Complex128)); + return hashing_proc(v.value_complex, gb_size_of(Complex128)); case ExactValue_Quaternion: - return hashing_proc(&v.value_quaternion, gb_size_of(Quaternion256)); + return hashing_proc(v.value_quaternion, gb_size_of(Quaternion256)); case ExactValue_Compound: return hash_pointer(v.value_compound); case ExactValue_Procedure: @@ -139,17 +139,19 @@ ExactValue exact_value_float(f64 f) { ExactValue exact_value_complex(f64 real, f64 imag) { ExactValue result = {ExactValue_Complex}; - result.value_complex.real = real; - result.value_complex.imag = imag; + result.value_complex = gb_alloc_item(permanent_allocator(), Complex128); + result.value_complex->real = real; + result.value_complex->imag = imag; return result; } ExactValue exact_value_quaternion(f64 real, f64 imag, f64 jmag, f64 kmag) { ExactValue result = {ExactValue_Quaternion}; - result.value_quaternion.real = real; - result.value_quaternion.imag = imag; - result.value_quaternion.jmag = jmag; - result.value_quaternion.kmag = kmag; + result.value_quaternion = gb_alloc_item(permanent_allocator(), Quaternion256); + result.value_quaternion->real = real; + result.value_quaternion->imag = imag; + result.value_quaternion->jmag = jmag; + result.value_quaternion->kmag = kmag; return result; } @@ -373,6 +375,7 @@ ExactValue exact_value_to_complex(ExactValue v) { // return exact_value_complex(v.value_quaternion.real, v.value_quaternion.imag); } ExactValue r = {ExactValue_Invalid}; + v.value_complex = gb_alloc_item(permanent_allocator(), Complex128); return r; } ExactValue exact_value_to_quaternion(ExactValue v) { @@ -382,11 +385,12 @@ ExactValue exact_value_to_quaternion(ExactValue v) { case ExactValue_Float: return exact_value_quaternion(v.value_float, 0, 0, 0); case ExactValue_Complex: - return exact_value_quaternion(v.value_complex.real, v.value_complex.imag, 0, 0); + return exact_value_quaternion(v.value_complex->real, v.value_complex->imag, 0, 0); case ExactValue_Quaternion: return v; } ExactValue r = {ExactValue_Invalid}; + v.value_quaternion = gb_alloc_item(permanent_allocator(), Quaternion256); return r; } @@ -396,9 +400,9 @@ ExactValue exact_value_real(ExactValue v) { case ExactValue_Float: return v; case ExactValue_Complex: - return exact_value_float(v.value_complex.real); + return exact_value_float(v.value_complex->real); case ExactValue_Quaternion: - return exact_value_float(v.value_quaternion.real); + return exact_value_float(v.value_quaternion->real); } ExactValue r = {ExactValue_Invalid}; return r; @@ -410,9 +414,9 @@ ExactValue exact_value_imag(ExactValue v) { case ExactValue_Float: return exact_value_i64(0); case ExactValue_Complex: - return exact_value_float(v.value_complex.imag); + return exact_value_float(v.value_complex->imag); case ExactValue_Quaternion: - return exact_value_float(v.value_quaternion.imag); + return exact_value_float(v.value_quaternion->imag); } ExactValue r = {ExactValue_Invalid}; return r; @@ -425,7 +429,7 @@ ExactValue exact_value_jmag(ExactValue v) { case ExactValue_Complex: return exact_value_i64(0); case ExactValue_Quaternion: - return exact_value_float(v.value_quaternion.jmag); + return exact_value_float(v.value_quaternion->jmag); } ExactValue r = {ExactValue_Invalid}; return r; @@ -438,7 +442,7 @@ ExactValue exact_value_kmag(ExactValue v) { case ExactValue_Complex: return exact_value_i64(0); case ExactValue_Quaternion: - return exact_value_float(v.value_quaternion.kmag); + return exact_value_float(v.value_quaternion->kmag); } ExactValue r = {ExactValue_Invalid}; return r; @@ -532,15 +536,15 @@ ExactValue exact_unary_operator_value(TokenKind op, ExactValue v, i32 precision, return i; } case ExactValue_Complex: { - f64 real = v.value_complex.real; - f64 imag = v.value_complex.imag; + f64 real = v.value_complex->real; + f64 imag = v.value_complex->imag; return exact_value_complex(-real, -imag); } case ExactValue_Quaternion: { - f64 real = v.value_quaternion.real; - f64 imag = v.value_quaternion.imag; - f64 jmag = v.value_quaternion.jmag; - f64 kmag = v.value_quaternion.kmag; + f64 real = v.value_quaternion->real; + f64 imag = v.value_quaternion->imag; + f64 jmag = v.value_quaternion->jmag; + f64 kmag = v.value_quaternion->kmag; return exact_value_quaternion(-real, -imag, -jmag, -kmag); } } @@ -732,10 +736,10 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) case ExactValue_Complex: { y = exact_value_to_complex(y); - f64 a = x.value_complex.real; - f64 b = x.value_complex.imag; - f64 c = y.value_complex.real; - f64 d = y.value_complex.imag; + f64 a = x.value_complex->real; + f64 b = x.value_complex->imag; + f64 c = y.value_complex->real; + f64 d = y.value_complex->imag; f64 real = 0; f64 imag = 0; switch (op) { @@ -765,14 +769,14 @@ ExactValue exact_binary_operator_value(TokenKind op, ExactValue x, ExactValue y) case ExactValue_Quaternion: { y = exact_value_to_quaternion(y); - f64 xr = x.value_quaternion.real; - f64 xi = x.value_quaternion.imag; - f64 xj = x.value_quaternion.jmag; - f64 xk = x.value_quaternion.kmag; - f64 yr = y.value_quaternion.real; - f64 yi = y.value_quaternion.imag; - f64 yj = y.value_quaternion.jmag; - f64 yk = y.value_quaternion.kmag; + f64 xr = x.value_quaternion->real; + f64 xi = x.value_quaternion->imag; + f64 xj = x.value_quaternion->jmag; + f64 xk = x.value_quaternion->kmag; + f64 yr = y.value_quaternion->real; + f64 yi = y.value_quaternion->imag; + f64 yj = y.value_quaternion->jmag; + f64 yk = y.value_quaternion->kmag; f64 real = 0; @@ -899,10 +903,10 @@ bool compare_exact_values(TokenKind op, ExactValue x, ExactValue y) { } case ExactValue_Complex: { - f64 a = x.value_complex.real; - f64 b = x.value_complex.imag; - f64 c = y.value_complex.real; - f64 d = y.value_complex.imag; + f64 a = x.value_complex->real; + f64 b = x.value_complex->imag; + f64 c = y.value_complex->real; + f64 d = y.value_complex->imag; switch (op) { case Token_CmpEq: return cmp_f64(a, c) == 0 && cmp_f64(b, d) == 0; case Token_NotEq: return cmp_f64(a, c) != 0 || cmp_f64(b, d) != 0; @@ -978,7 +982,9 @@ gbString write_exact_value_to_string(gbString str, ExactValue const &v, isize st case ExactValue_Float: return gb_string_append_fmt(str, "%f", v.value_float); case ExactValue_Complex: - return gb_string_append_fmt(str, "%f+%fi", v.value_complex.real, v.value_complex.imag); + return gb_string_append_fmt(str, "%f+%fi", v.value_complex->real, v.value_complex->imag); + case ExactValue_Quaternion: + return gb_string_append_fmt(str, "%f+%fi+%fj+%fk", v.value_quaternion->real, v.value_quaternion->imag, v.value_quaternion->jmag, v.value_quaternion->kmag); case ExactValue_Pointer: return str; diff --git a/src/ir_print.cpp b/src/ir_print.cpp index cb71589c5..a04f7b657 100644 --- a/src/ir_print.cpp +++ b/src/ir_print.cpp @@ -953,9 +953,9 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * ir_write_byte(f, ' '); ir_write_byte(f, '{'); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_complex.real), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_complex->real), ft); ir_write_str_lit(f, ", "); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_complex.imag), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_complex->imag), ft); ir_write_byte(f, '}'); break; } @@ -968,13 +968,13 @@ void ir_print_exact_value(irFileBuffer *f, irModule *m, ExactValue value, Type * ir_write_byte(f, ' '); ir_write_byte(f, '{'); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_quaternion.imag), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_quaternion->imag), ft); ir_write_str_lit(f, ", "); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_quaternion.jmag), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_quaternion->jmag), ft); ir_write_str_lit(f, ", "); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_quaternion.kmag), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_quaternion->kmag), ft); ir_write_str_lit(f, ", "); ir_print_type(f, m, ft); ir_write_byte(f, ' '); - ir_print_exact_value(f, m, exact_value_float(value.value_quaternion.real), ft); + ir_print_exact_value(f, m, exact_value_float(value.value_quaternion->real), ft); ir_write_byte(f, '}'); break; } diff --git a/src/llvm_backend.cpp b/src/llvm_backend.cpp index 11b301268..b4edc4914 100644 --- a/src/llvm_backend.cpp +++ b/src/llvm_backend.cpp @@ -5316,12 +5316,12 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc LLVMValueRef values[2] = {}; switch (8*type_size_of(type)) { case 64: - values[0] = lb_const_f32(m, cast(f32)value.value_complex.real); - values[1] = lb_const_f32(m, cast(f32)value.value_complex.imag); + values[0] = lb_const_f32(m, cast(f32)value.value_complex->real); + values[1] = lb_const_f32(m, cast(f32)value.value_complex->imag); break; case 128: - values[0] = LLVMConstReal(lb_type(m, t_f64), value.value_complex.real); - values[1] = LLVMConstReal(lb_type(m, t_f64), value.value_complex.imag); + values[0] = LLVMConstReal(lb_type(m, t_f64), value.value_complex->real); + values[1] = LLVMConstReal(lb_type(m, t_f64), value.value_complex->imag); break; } @@ -5335,17 +5335,17 @@ lbValue lb_const_value(lbModule *m, Type *type, ExactValue value, bool allow_loc switch (8*type_size_of(type)) { case 128: // @QuaternionLayout - values[3] = lb_const_f32(m, cast(f32)value.value_quaternion.real); - values[0] = lb_const_f32(m, cast(f32)value.value_quaternion.imag); - values[1] = lb_const_f32(m, cast(f32)value.value_quaternion.jmag); - values[2] = lb_const_f32(m, cast(f32)value.value_quaternion.kmag); + values[3] = lb_const_f32(m, cast(f32)value.value_quaternion->real); + values[0] = lb_const_f32(m, cast(f32)value.value_quaternion->imag); + values[1] = lb_const_f32(m, cast(f32)value.value_quaternion->jmag); + values[2] = lb_const_f32(m, cast(f32)value.value_quaternion->kmag); break; case 256: // @QuaternionLayout - values[3] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion.real); - values[0] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion.imag); - values[1] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion.jmag); - values[2] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion.kmag); + values[3] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion->real); + values[0] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion->imag); + values[1] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion->jmag); + values[2] = LLVMConstReal(lb_type(m, t_f64), value.value_quaternion->kmag); break; }