ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-24 00:17:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix interval loop constant bug; Fix ir edge checking; Fix vector arithmetic with scalars

Browse Source
This commit is contained in:
Ginger Bill
2017-05-22 23:29:09 +01:00
parent 41aa4e606b
commit ddb99dd638
5 changed files with 58 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/math.odin
+7 -8
View File
@@ -319,15 +319,14 @@ look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
s := norm(cross(f, up));
u := cross(s, f);
m: Mat4;
m[0] = [4]f32{+s.x, +s.y, +s.z, 0};
m[1] = [4]f32{+u.x, +u.y, +u.z, 0};
m[2] = [4]f32{-f.x, -f.y, -f.z, 0};
m[3] = [4]f32{dot(s, eye), dot(u, eye), dot(f, eye), 1};
return m;
return Mat4{
{+s.x, +u.x, -f.x, 0},
{+s.y, +u.y, -f.y, 0},
{+s.z, +u.z, -f.z, 0},
{-dot(s, eye), -dot(u, eye), dot(f, eye), 1},
};
}
perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
m: Mat4;
tan_half_fovy := tan(0.5 * fovy);
src/check_expr.c
+29 -40
View File
@@ -3345,10 +3345,15 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
}
}
bool vari_expand = (ce->ellipsis.pos.line != 0);
if (vari_expand && id != BuiltinProc_append) {
error(ce->ellipsis, "Invalid use of `..` with built-in procedure `append`");
return false;
}
switch (id) {
case BuiltinProc_new:
// case BuiltinProc_new_slice:
case BuiltinProc_make:
case BuiltinProc_size_of:
case BuiltinProc_align_of:
@@ -4083,50 +4088,34 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
check_expr(c, &z, ce->args.e[2]); if (z.mode == Addressing_Invalid) return false;
check_expr(c, &w, ce->args.e[3]); if (w.mode == Addressing_Invalid) return false;
convert_to_typed(c, &x, y.type, 0); if (x.mode == Addressing_Invalid) return false;
convert_to_typed(c, &x, z.type, 0); if (x.mode == Addressing_Invalid) return false;
convert_to_typed(c, &x, w.type, 0); if (x.mode == Addressing_Invalid) return false;
convert_to_typed(c, &y, z.type, 0); if (y.mode == Addressing_Invalid) return false;
convert_to_typed(c, &y, w.type, 0); if (y.mode == Addressing_Invalid) return false;
convert_to_typed(c, &y, x.type, 0); if (y.mode == Addressing_Invalid) return false;
convert_to_typed(c, &z, y.type, 0); if (z.mode == Addressing_Invalid) return false;
convert_to_typed(c, &z, w.type, 0); if (z.mode == Addressing_Invalid) return false;
convert_to_typed(c, &z, x.type, 0); if (z.mode == Addressing_Invalid) return false;
convert_to_typed(c, &w, x.type, 0); if (w.mode == Addressing_Invalid) return false;
convert_to_typed(c, &w, y.type, 0); if (w.mode == Addressing_Invalid) return false;
convert_to_typed(c, &w, z.type, 0); if (w.mode == Addressing_Invalid) return false;
#define _QUAT_CTT(x, y, z, w) do { \
convert_to_typed(c, &(x), (y).type, 0); if ((x).mode == Addressing_Invalid) return false; \
convert_to_typed(c, &(x), (z).type, 0); if ((x).mode == Addressing_Invalid) return false; \
convert_to_typed(c, &(x), (w).type, 0); if ((x).mode == Addressing_Invalid) return false; \
} while (0)
_QUAT_CTT(x, y, z, w);
_QUAT_CTT(y, z, w, x);
_QUAT_CTT(z, w, x, y);
_QUAT_CTT(w, x, y, z);
#undef _QUAT_CTT
if (x.mode == Addressing_Constant &&
y.mode == Addressing_Constant &&
z.mode == Addressing_Constant &&
w.mode == Addressing_Constant) {
if (is_type_numeric(x.type) &&
exact_value_imag(x.value).value_float == 0 &&
exact_value_jmag(x.value).value_float == 0 &&
exact_value_kmag(x.value).value_float == 0) {
x.type = t_untyped_float;
}
if (is_type_numeric(y.type) &&
exact_value_imag(y.value).value_float == 0 &&
exact_value_jmag(y.value).value_float == 0 &&
exact_value_kmag(y.value).value_float == 0) {
y.type = t_untyped_float;
}
if (is_type_numeric(z.type) &&
exact_value_imag(z.value).value_float == 0 &&
exact_value_jmag(z.value).value_float == 0 &&
exact_value_kmag(z.value).value_float == 0) {
z.type = t_untyped_float;
}
if (is_type_numeric(w.type) &&
exact_value_imag(w.value).value_float == 0 &&
exact_value_jmag(w.value).value_float == 0 &&
exact_value_kmag(w.value).value_float == 0) {
w.type = t_untyped_float;
}
#define _QUAT_EXACT_VAL(x) do { \
if (is_type_numeric((x).type) && \
exact_value_imag((x).value).value_float == 0 && \
exact_value_jmag((x).value).value_float == 0 && \
exact_value_kmag((x).value).value_float == 0) { \
(x).type = t_untyped_float; \
} \
} while (0)
_QUAT_EXACT_VAL(x);
_QUAT_EXACT_VAL(y);
_QUAT_EXACT_VAL(z);
_QUAT_EXACT_VAL(w);
#undef _QUAT_EXACT_VAL
}
if (!are_types_identical(x.type, y.type)) {
src/check_stmt.c
+8
View File
@@ -918,6 +918,14 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
}
}
if (x.mode != Addressing_Constant) {
x.value = (ExactValue){0};
}
if (y.mode != Addressing_Constant) {
y.value = (ExactValue){0};
}
add_type_and_value(&c->info, ie->left, x.mode, x.type, x.value);
add_type_and_value(&c->info, ie->right, y.mode, y.type, y.value);
val = type;
src/ir.c
+13 -8
View File
@@ -673,8 +673,11 @@ bool ir_is_instr_terminating(irInstr *i) {
void ir_add_edge(irBlock *from, irBlock *to) {
array_add(&from->succs, to);
array_add(&to->preds, from);
GB_ASSERT(from->instrs.count > 0);
if (!ir_is_instr_terminating(ir_get_last_instr(from))) {
array_add(&from->succs, to);
array_add(&to->preds, from);
}
}
void ir_set_instr_parent(irValue *instr, irBlock *parent) {
@@ -1812,14 +1815,15 @@ irValue *ir_emit_unary_arith(irProcedure *proc, TokenKind op, irValue *x, Type *
return ir_emit(proc, ir_instr_unary_op(proc, op, x, type));
}
irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *right, Type *type) {
Type *t_left = ir_type(left);
Type *t_right = ir_type(right);
if (is_type_vector(t_left)) {
if (is_type_vector(t_left) || is_type_vector(t_right)) {
ir_emit_comment(proc, str_lit("vector.arith.begin"));
// IMPORTANT TODO(bill): This is very wasteful with regards to stack memory
Type *tl = base_type(t_left);
left = ir_emit_conv(proc, left, type);
right = ir_emit_conv(proc, right, type);
irValue *lhs = ir_address_from_load_or_generate_local(proc, left);
@@ -1828,7 +1832,8 @@ irValue *ir_emit_arith(irProcedure *proc, TokenKind op, irValue *left, irValue *
Type *elem_type = base_type(type)->Vector.elem;
irValue *res = ir_add_local_generated(proc, type);
for (i32 i = 0; i < tl->Vector.count; i++) {
i64 count = base_type(type)->Vector.count;
for (i32 i = 0; i < count; i++) {
irValue *x = ir_emit_load(proc, ir_emit_array_epi(proc, lhs, i));
irValue *y = ir_emit_load(proc, ir_emit_array_epi(proc, rhs, i));
irValue *z = ir_emit_arith(proc, op, x, y, elem_type);
@@ -5640,7 +5645,6 @@ void ir_build_range_string(irProcedure *proc, irValue *expr, Type *val_type,
done = ir_new_block(proc, NULL, "for.string.done");
irValue *offset = ir_emit_load(proc, offset_);
irValue *cond = ir_emit_comp(proc, Token_Lt, offset, count);
ir_emit_if(proc, cond, body, done);
ir_start_block(proc, body);
@@ -5696,7 +5700,6 @@ void ir_build_range_interval(irProcedure *proc, AstNodeBinaryExpr *node, Type *v
body = ir_new_block(proc, NULL, "for.interval.body");
done = ir_new_block(proc, NULL, "for.interval.done");
upper = ir_build_expr(proc, node->right);
TokenKind op = Token_Lt;
switch (node->op.kind) {
@@ -5704,6 +5707,9 @@ void ir_build_range_interval(irProcedure *proc, AstNodeBinaryExpr *node, Type *v
case Token_HalfClosed: op = Token_Lt; break;
default: GB_PANIC("Invalid interval operator"); break;
}
upper = ir_build_expr(proc, node->right);
irValue *cond = ir_emit_comp(proc, op, ir_emit_load(proc, value), upper);
ir_emit_if(proc, cond, body, done);
ir_start_block(proc, body);
@@ -6222,7 +6228,6 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) {
GB_PANIC("TODO(bill): enum core type %s", type_to_string(core_elem));
}
}
} else {
Type *expr_type = type_of_expr(proc->module->info, rs->expr);
Type *et = base_type(type_deref(expr_type));
src/ir_print.c
+1 -1
View File
@@ -1060,7 +1060,7 @@ void ir_print_instr(irFileBuffer *f, irModule *m, irValue *value) {
irInstrBinaryOp *bo = &value->Instr.BinaryOp;
Type *type = base_type(ir_type(bo->left));
Type *elem_type = type;
GB_ASSERT(!is_type_vector(elem_type));
GB_ASSERT_MSG(!is_type_vector(elem_type), type_to_string(elem_type));
ir_fprintf(f, "%%%d = ", value->index);