x86-64 emitters need a way to determine the required operand size. We
modify get_var() so it stores vm_type in struct var_info, making it
available from struct operand.
Signed-off-by: Eduard - Gabriel Munteanu <eduard.munte...@linux360.ro>
---
arch/x86/include/arch/registers_32.h | 3 +
arch/x86/include/arch/registers_64.h | 2 +
arch/x86/insn-selector_32.brg | 70 ++++++++++++++++----------------
include/jit/compilation-unit.h | 3 +-
include/jit/vars.h | 4 +-
jit/bytecode-to-ir.c | 4 +-
jit/compilation-unit.c | 8 ++-
jit/object-bc.c | 2 +-
jit/ostack-bc.c | 4 +-
test/arch-x86/insn-selector-test_32.c | 8 ++--
test/jit/arithmetic-bc-test.c | 10 ++--
test/jit/branch-bc-test.c | 6 +-
test/jit/invoke-bc-test.c | 2 +-
test/jit/linear-scan-test.c | 10 ++--
test/jit/liveness-test.c | 8 ++--
test/jit/load-store-bc-test.c | 2 +-
test/jit/object-bc-test.c | 2 +-
test/jit/spill-reload-test.c | 10 ++--
test/jit/typeconv-bc-test.c | 2 +-
19 files changed, 85 insertions(+), 75 deletions(-)
diff --git a/arch/x86/include/arch/registers_32.h
b/arch/x86/include/arch/registers_32.h
index 1547e33..ce9058e 100644
--- a/arch/x86/include/arch/registers_32.h
+++ b/arch/x86/include/arch/registers_32.h
@@ -4,6 +4,7 @@
#include <limits.h>
#include <stdbool.h>
#include <assert.h>
+#include <vm/types.h>
enum machine_reg {
REG_EAX,
@@ -41,6 +42,8 @@ enum machine_reg {
REG_UNASSIGNED = INT_MAX,
};
+#define GPR_VM_TYPE J_INT
+
const char *reg_name(enum machine_reg reg);
enum machine_reg_type reg_type(enum machine_reg reg);
diff --git a/arch/x86/include/arch/registers_64.h
b/arch/x86/include/arch/registers_64.h
index a354403..0725686 100644
--- a/arch/x86/include/arch/registers_64.h
+++ b/arch/x86/include/arch/registers_64.h
@@ -39,6 +39,8 @@ enum machine_reg {
REG_UNASSIGNED = INT_MAX,
};
+#define GPR_VM_TYPE J_LONG
+
const char *reg_name(enum machine_reg reg);
static inline bool is_caller_saved_reg(enum machine_reg reg)
diff --git a/arch/x86/insn-selector_32.brg b/arch/x86/insn-selector_32.brg
index 2fe197c..c0f418e 100644
--- a/arch/x86/insn-selector_32.brg
+++ b/arch/x86/insn-selector_32.brg
@@ -157,7 +157,7 @@ reg: freg 1
struct var_info *result, *in, *esp;
in = state->reg1;
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg1 = result;
esp = get_fixed_var(s->b_parent, REG_ESP);
@@ -187,13 +187,13 @@ reg: EXPR_VALUE 0
expr = to_expr(tree);
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg1 = result;
select_insn(s, tree, imm_reg_insn(INSN_MOV_IMM_REG, expr->value & ~0UL,
result));
if (expr->vm_type == J_LONG) {
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg2 = result;
select_insn(s, tree, imm_reg_insn(INSN_MOV_IMM_REG, expr->value
>> 32, state->reg2));
}
@@ -209,7 +209,7 @@ reg: EXPR_LOCAL 1
expr = to_expr(tree);
slot = get_local_slot(cu->stack_frame, expr->local_index);
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg1 = result;
select_insn(s, tree, memlocal_reg_insn(INSN_MOV_MEMLOCAL_REG, slot,
result));
@@ -217,7 +217,7 @@ reg: EXPR_LOCAL 1
if (expr->vm_type == J_LONG) {
slot = get_local_slot(cu->stack_frame, expr->local_index + 1);
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg2 = result;
select_insn(s, tree, memlocal_reg_insn(INSN_MOV_MEMLOCAL_REG,
slot, result));
@@ -390,9 +390,9 @@ reg: OP_MUL_64(reg, reg) 1
edx = get_fixed_var(s->b_parent, REG_EDX);
state->reg1 = eax;
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
- tmp1 = get_var(s->b_parent);
+ tmp1 = get_var(s->b_parent, J_INT);
select_insn(s, tree, reg_reg_insn(INSN_MOV_REG_REG, state->right->reg2,
tmp1));
select_insn(s, tree, reg_reg_insn(INSN_MUL_REG_REG, state->left->reg1,
tmp1));
select_insn(s, tree, reg_reg_insn(INSN_MOV_REG_REG, state->left->reg2,
state->reg2));
@@ -691,11 +691,11 @@ reg: EXPR_INVOKE(arg) 1
cu = method->compilation_unit;
eax = get_fixed_var(s->b_parent, REG_EAX);
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
if (get_method_return_type(method->type) == J_LONG) {
edx = get_fixed_var(s->b_parent, REG_EDX);
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
}
invoke(s, tree, cu, method);
@@ -722,18 +722,18 @@ reg: EXPR_INVOKEINTERFACE(arg) 1
method_offset = expr_method_index(expr) * sizeof(void *);
eax = get_fixed_var(s->b_parent, REG_EAX);
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
if (get_method_return_type(method->type) == J_LONG) {
edx = get_fixed_var(s->b_parent, REG_EDX);
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
}
/* object reference */
objectref_expr = get_first_arg(expr->args_list);
if (expr_type(objectref_expr) == EXPR_VALUE) {
- call_target = get_var(s->b_parent);
+ call_target = get_var(s->b_parent, J_INT);
select_insn(s, tree, imm_reg_insn(INSN_MOV_IMM_REG,
objectref_expr->value, call_target));
} else {
call_target = state->left->reg1;
@@ -793,11 +793,11 @@ reg: EXPR_INVOKEVIRTUAL(arg) 1
method = expr->target_method;
eax = get_fixed_var(s->b_parent, REG_EAX);
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
if (get_method_return_type(method->type) == J_LONG) {
edx = get_fixed_var(s->b_parent, REG_EDX);
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
}
invokevirtual(state, s, tree);
@@ -827,7 +827,7 @@ reg: OP_CMPL(freg, freg) 1
{
struct var_info *esp, *eax;
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
esp = get_fixed_var(s->b_parent, REG_ESP);
eax = get_fixed_var(s->b_parent, REG_EAX);
@@ -856,7 +856,7 @@ reg: OP_CMP(reg, EXPR_VALUE) 1
expr = to_expr(tree);
right = to_expr(expr->binary_right);
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
eax = get_fixed_var(s->b_parent, REG_EAX);
if (right->vm_type != J_LONG) {
@@ -977,7 +977,7 @@ reg: EXPR_CLASS_FIELD 1
expr = to_expr(tree);
- out = get_var(s->b_parent);
+ out = get_var(s->b_parent, J_INT);
state->reg1 = out;
vmf = expr->class_field;
@@ -1001,7 +1001,7 @@ reg: EXPR_CLASS_FIELD 1
select_insn(s, tree, mov_insn);
if (expr->vm_type == J_LONG) {
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
select_insn(s, tree, memdisp_reg_insn(INSN_MOV_MEMDISP_REG,
(unsigned long) vmc->static_values + vmf->offset + 4,
state->reg2));
@@ -1017,13 +1017,13 @@ reg: EXPR_INSTANCE_FIELD(reg) 1
expr = to_expr(tree);
base = state->left->reg1;
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
offset = sizeof(struct vm_object) + expr->instance_field->offset;
select_insn(s, tree, membase_reg_insn(INSN_MOV_MEMBASE_REG, base,
offset, state->reg1));
if (expr->vm_type == J_LONG) {
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
select_insn(s, tree, membase_reg_insn(INSN_MOV_MEMBASE_REG,
base, offset + 4, state->reg2));
}
}
@@ -1096,7 +1096,7 @@ reg: EXPR_NULL_CHECK(EXPR_LOCAL)
struct expression *expr;
struct expression *local;
- reg = get_var(s->b_parent);
+ reg = get_var(s->b_parent, J_INT);
state->reg1 = reg;
expr = to_expr(tree);
@@ -1179,7 +1179,7 @@ reg: EXPR_ARRAYLENGTH(reg)
arrayref = state->left->reg1;
- arraylength = get_var(s->b_parent);
+ arraylength = get_var(s->b_parent, J_INT);
state->reg1 = arraylength;
select_insn(s, tree, membase_reg_insn(INSN_MOV_MEMBASE_REG, arrayref,
@@ -1214,8 +1214,8 @@ reg: EXPR_CONVERSION(reg)
src = to_expr(expr->from_expression);
if (src->vm_type == J_INT && expr->vm_type == J_LONG) {
- state->reg1 = get_var(s->b_parent);
- state->reg2 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
+ state->reg2 = get_var(s->b_parent, J_INT);
select_insn(s, tree, reg_reg_insn(INSN_MOV_REG_REG,
state->left->reg1, state->reg1));
select_insn(s, tree, reg_reg_insn(INSN_MOV_REG_REG,
state->left->reg1, state->reg2));
@@ -1223,11 +1223,11 @@ reg: EXPR_CONVERSION(reg)
} else if (src->vm_type == J_LONG && expr->vm_type == J_INT) {
state->reg1 = state->left->reg1;
} else if (src->vm_type == J_INT && expr->vm_type == J_BYTE) {
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
select_insn(s, tree, reg_reg_insn(INSN_MOVSX_8_REG_REG,
state->left->reg1, state->reg1));
} else if (src->vm_type == J_INT && expr->vm_type == J_CHAR) {
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
select_insn(s, tree, reg_reg_insn(INSN_MOVSX_16_REG_REG,
state->left->reg1, state->reg1));
} else {
@@ -1261,7 +1261,7 @@ reg: EXPR_CONVERSION_FROM_FLOAT(freg)
src = to_expr(expr->from_expression);
if (src->vm_type == J_FLOAT && expr->vm_type == J_INT) {
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
select_insn(s, tree, reg_reg_insn(INSN_CONV_FPU_TO_GPR,
state->left->reg1, state->reg1));
} else {
@@ -1332,7 +1332,7 @@ reg: EXPR_EXCEPTION_REF
struct var_info *result;
struct stack_slot *slot = s->b_parent->exception_spill_slot;
- result = get_var(s->b_parent);
+ result = get_var(s->b_parent, J_INT);
state->reg1 = result;
select_insn(s, tree, memlocal_reg_insn(INSN_MOV_MEMLOCAL_REG, slot,
result));
@@ -1543,7 +1543,7 @@ array_deref: EXPR_ARRAY_DEREF(reg, reg) 2
state_base = state->left->reg1;
- base = get_var(s->b_parent);
+ base = get_var(s->b_parent, J_INT);
state->reg1 = base;
state->reg2 = state->right->reg1;
@@ -1637,10 +1637,10 @@ array_check: EXPR_ARRAY_DEREF(reg, reg) 2
state_base = state->left->reg1;
state_index = state->right->reg1;
- base = get_var(s->b_parent);
+ base = get_var(s->b_parent, J_INT);
state->reg1 = base;
- index = get_var(s->b_parent);
+ index = get_var(s->b_parent, J_INT);
state->reg2 = index;
select_insn(s, tree, reg_reg_insn(INSN_MOV_REG_REG, state_base, base));
@@ -1747,7 +1747,7 @@ static void select_exception_test(struct basic_block *bb,
unsigned long exception_guard_offset;
struct var_info *reg;
- reg = get_var(bb->b_parent);
+ reg = get_var(bb->b_parent, J_INT);
exception_guard_offset = get_thread_local_offset(&exception_guard);
@@ -1890,11 +1890,11 @@ emulate_op_64(struct _MBState *state, struct
basic_block *s,
struct var_info *eax, *edx = NULL;
eax = get_fixed_var(s->b_parent, REG_EAX);
- state->reg1 = get_var(s->b_parent);
+ state->reg1 = get_var(s->b_parent, J_INT);
if (return_type == J_LONG) {
edx = get_fixed_var(s->b_parent, REG_EDX);
- state->reg2 = get_var(s->b_parent);
+ state->reg2 = get_var(s->b_parent, J_INT);
}
select_insn(s, tree, reg_insn(INSN_PUSH_REG, state->right->reg2));
select_insn(s, tree, reg_insn(INSN_PUSH_REG, state->right->reg1));
@@ -1968,7 +1968,7 @@ static void invokevirtual(struct _MBState *state, struct
basic_block *s, struct
objectref_expr = get_first_arg(expr->args_list);
if (expr_type(objectref_expr) == EXPR_VALUE) {
- call_target = get_var(s->b_parent);
+ call_target = get_var(s->b_parent, J_INT);
select_insn(s, tree, imm_reg_insn(INSN_MOV_IMM_REG,
objectref_expr->value, call_target));
} else {
call_target = state->left->reg1;
diff --git a/include/jit/compilation-unit.h b/include/jit/compilation-unit.h
index 968cf9e..1066d4b 100644
--- a/include/jit/compilation-unit.h
+++ b/include/jit/compilation-unit.h
@@ -6,6 +6,7 @@
#include "lib/list.h"
#include "vm/stack.h"
#include "vm/static.h"
+#include "vm/types.h"
#include "arch/stack-frame.h"
@@ -57,7 +58,7 @@ struct compilation_unit {
struct compilation_unit *compilation_unit_alloc(struct vm_method *);
int init_stack_slots(struct compilation_unit *cu);
void free_compilation_unit(struct compilation_unit *);
-struct var_info *get_var(struct compilation_unit *);
+struct var_info *get_var(struct compilation_unit *, enum vm_type);
struct var_info *get_fpu_var(struct compilation_unit *);
struct var_info *get_fixed_var(struct compilation_unit *, enum machine_reg);
struct basic_block *find_bb(struct compilation_unit *, unsigned long);
diff --git a/include/jit/vars.h b/include/jit/vars.h
index 9a89ff6..482f10a 100644
--- a/include/jit/vars.h
+++ b/include/jit/vars.h
@@ -3,6 +3,7 @@
#include "lib/list.h"
#include "arch/registers.h"
+#include "vm/types.h"
#include <stdbool.h>
#include <assert.h>
@@ -102,7 +103,8 @@ struct var_info {
unsigned long vreg;
struct var_info *next;
struct live_interval *interval;
- enum machine_reg_type type;
+ enum machine_reg_type type;
+ enum vm_type vm_type;
};
struct live_interval *alloc_interval(struct var_info *);
diff --git a/jit/bytecode-to-ir.c b/jit/bytecode-to-ir.c
index 7cf6df9..decabb4 100644
--- a/jit/bytecode-to-ir.c
+++ b/jit/bytecode-to-ir.c
@@ -334,9 +334,9 @@ static void pick_and_propagate_temporaries(struct
basic_block *bb, bool entry)
if (expr->entry != entry)
continue;
- tmp_low = get_var(bb->b_parent);
+ tmp_low = get_var(bb->b_parent, J_INT);
if (expr->vm_type == J_LONG)
- tmp_high = get_var(bb->b_parent);
+ tmp_high = get_var(bb->b_parent, J_INT);
else
tmp_high = NULL;
diff --git a/jit/compilation-unit.c b/jit/compilation-unit.c
index c6e8ef1..2f1cb26 100644
--- a/jit/compilation-unit.c
+++ b/jit/compilation-unit.c
@@ -110,7 +110,7 @@ void free_compilation_unit(struct compilation_unit *cu)
free(cu);
}
-struct var_info *get_var(struct compilation_unit *cu)
+struct var_info *get_var(struct compilation_unit *cu, enum vm_type vm_type)
{
struct var_info *ret;
@@ -123,6 +123,7 @@ struct var_info *get_var(struct compilation_unit *cu)
ret->interval = alloc_interval(ret);
ret->type = REG_TYPE_GPR;
+ ret->vm_type = vm_type;
cu->var_infos = ret;
out:
@@ -131,7 +132,7 @@ struct var_info *get_var(struct compilation_unit *cu)
struct var_info *get_fpu_var(struct compilation_unit *cu)
{
- struct var_info *ret = get_var(cu);
+ struct var_info *ret = get_var(cu, J_FLOAT);
ret->type = REG_TYPE_FPU;
@@ -142,11 +143,12 @@ struct var_info *get_fixed_var(struct compilation_unit
*cu, enum machine_reg reg
{
struct var_info *ret;
- ret = get_var(cu);
+ ret = get_var(cu, J_INT);
if (ret) {
ret->interval->reg = reg;
ret->interval->fixed_reg = true;
ret->type = reg_type(reg);
+ ret->vm_type = GPR_VM_TYPE;
}
return ret;
diff --git a/jit/object-bc.c b/jit/object-bc.c
index bc45396..e4eb12d 100644
--- a/jit/object-bc.c
+++ b/jit/object-bc.c
@@ -210,7 +210,7 @@ static int convert_array_load(struct parse_context *ctx,
enum vm_type type)
index_pure = get_pure_expr(ctx, index);
src_expr = array_deref_expr(type, arrayref_pure, index_pure);
- temporary = get_var(ctx->cu);
+ temporary = get_var(ctx->cu, J_INT);
dest_expr = temporary_expr(type, NULL, temporary);
store_stmt->store_src = &src_expr->node;
diff --git a/jit/ostack-bc.c b/jit/ostack-bc.c
index 7ddff3d..7c6388f 100644
--- a/jit/ostack-bc.c
+++ b/jit/ostack-bc.c
@@ -42,10 +42,10 @@ dup_expr(struct parse_context *ctx, struct expression *expr)
struct statement *stmt;
struct var_info *tmp_low, *tmp_high = NULL;
- tmp_low = get_var(ctx->cu);
+ tmp_low = get_var(ctx->cu, J_INT);
if (expr->vm_type == J_LONG) {
- tmp_high = get_var(ctx->cu);
+ tmp_high = get_var(ctx->cu, J_INT);
}
dest = temporary_expr(expr->vm_type, tmp_high, tmp_low);
diff --git a/test/arch-x86/insn-selector-test_32.c
b/test/arch-x86/insn-selector-test_32.c
index 8cf18d6..49336df 100644
--- a/test/arch-x86/insn-selector-test_32.c
+++ b/test/arch-x86/insn-selector-test_32.c
@@ -809,8 +809,8 @@ static void assert_select_if_statement_reg_reg(enum
insn_type expected,
};
cu = compilation_unit_alloc(&method);
- src = get_var(cu);
- dst = get_var(cu);
+ src = get_var(cu, J_INT);
+ dst = get_var(cu, J_INT);
bb = get_basic_block(cu, 0, 1);
true_bb = get_basic_block(cu, 1, 2);
@@ -1053,7 +1053,7 @@ void test_select_store_value_to_var(void)
cu = compilation_unit_alloc(&method);
- temporary = get_var(cu);
+ temporary = get_var(cu, J_INT);
store_dest = temporary_expr(J_REFERENCE, NULL, temporary);
store_src = value_expr(J_REFERENCE, 0xdeadbeef);
@@ -1092,7 +1092,7 @@ void test_select_store_var_to_local(void)
cu = compilation_unit_alloc(&method);
store_dest = local_expr(J_INT, 0);
- temporary = get_var(cu);
+ temporary = get_var(cu, J_INT);
store_src = temporary_expr(J_INT, NULL, temporary);
stmt = alloc_statement(STMT_STORE);
diff --git a/test/jit/arithmetic-bc-test.c b/test/jit/arithmetic-bc-test.c
index 87f8985..153b71e 100644
--- a/test/jit/arithmetic-bc-test.c
+++ b/test/jit/arithmetic-bc-test.c
@@ -41,10 +41,10 @@ static void assert_convert_binop(enum vm_type vm_type,
bb = __alloc_simple_bb(&method);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
left = temporary_expr(vm_type, NULL, temporary);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
right = temporary_expr(vm_type, NULL, temporary);
stack_push(bb->mimic_stack, left);
@@ -115,7 +115,7 @@ static void assert_convert_unop(enum vm_type vm_type,
bb = __alloc_simple_bb(&method);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
expression = temporary_expr(vm_type, NULL, temporary);
stack_push(bb->mimic_stack, expression);
@@ -223,10 +223,10 @@ static void assert_convert_cmp(unsigned char opc, enum
binary_operator op,
bb = __alloc_simple_bb(&method);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
left = temporary_expr(type, NULL, temporary);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
right = temporary_expr(type, NULL, temporary);
stack_push(bb->mimic_stack, left);
diff --git a/test/jit/branch-bc-test.c b/test/jit/branch-bc-test.c
index 3557afe..b393bd0 100644
--- a/test/jit/branch-bc-test.c
+++ b/test/jit/branch-bc-test.c
@@ -58,7 +58,7 @@ static void assert_convert_if(enum binary_operator
expected_operator,
list_add_tail(&bb->bb_list_node, &cu->bb_list);
list_add_tail(&target_bb->bb_list_node, &cu->bb_list);
- temporary = get_var(cu);
+ temporary = get_var(cu, J_INT);
if_value = temporary_expr(J_INT, NULL, temporary);
stack_push(branch_bb->mimic_stack, if_value);
@@ -108,11 +108,11 @@ static void assert_convert_if_cmp(enum binary_operator
expected_operator,
list_add_tail(&stmt_bb->bb_list_node, &cu->bb_list);
list_add_tail(&true_bb->bb_list_node, &cu->bb_list);
- temporary = get_var(cu);
+ temporary = get_var(cu, J_INT);
if_value1 = temporary_expr(vm_type, NULL, temporary);
stack_push(stmt_bb->mimic_stack, if_value1);
- temporary = get_var(cu);
+ temporary = get_var(cu, J_INT);
if_value2 = temporary_expr(vm_type, NULL, temporary);
stack_push(stmt_bb->mimic_stack, if_value2);
diff --git a/test/jit/invoke-bc-test.c b/test/jit/invoke-bc-test.c
index 5415e4c..647d3f4 100644
--- a/test/jit/invoke-bc-test.c
+++ b/test/jit/invoke-bc-test.c
@@ -25,7 +25,7 @@ static void assert_convert_return(enum vm_type vm_type,
unsigned char opc)
struct basic_block *bb;
bb = __alloc_simple_bb(&method);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
return_value = temporary_expr(vm_type, NULL, temporary);
stack_push(bb->mimic_stack, return_value);
convert_to_ir(bb->b_parent);
diff --git a/test/jit/linear-scan-test.c b/test/jit/linear-scan-test.c
index 7cd0484..8b581f9 100644
--- a/test/jit/linear-scan-test.c
+++ b/test/jit/linear-scan-test.c
@@ -18,11 +18,11 @@ void
test_allocates_different_registers_for_overlapping_intervals(void)
cu = compilation_unit_alloc(&method);
- v1 = get_var(cu);
+ v1 = get_var(cu, J_INT);
v1->interval->range.start = 0;
v1->interval->range.end = 2;
- v2 = get_var(cu);
+ v2 = get_var(cu, J_INT);
v2->interval->range.start = 1;
v2->interval->range.end = 2;
@@ -41,11 +41,11 @@ void
test_reuses_registers_for_non_overlapping_intervals(void)
cu = compilation_unit_alloc(&method);
- v1 = get_var(cu);
+ v1 = get_var(cu, J_INT);
v1->interval->range.start = 0;
v1->interval->range.end = 2;
- v2 = get_var(cu);
+ v2 = get_var(cu, J_INT);
v2->interval->range.start = 2;
v2->interval->range.end = 4;
@@ -68,7 +68,7 @@ void
test_honors_fixed_interval_register_constraint_for_overlapping_intervals(vo
v1->interval->range.start = 0;
v1->interval->range.end = 2;
- v2 = get_var(cu);
+ v2 = get_var(cu, J_INT);
v2->interval->range.start = 0;
v2->interval->range.end = 2;
diff --git a/test/jit/liveness-test.c b/test/jit/liveness-test.c
index d6e5198..f154206 100644
--- a/test/jit/liveness-test.c
+++ b/test/jit/liveness-test.c
@@ -39,8 +39,8 @@ void test_variable_range_limited_to_basic_block(void)
struct insn *insn[3];
cu = compilation_unit_alloc(&method);
- r1 = get_var(cu);
- r2 = get_var(cu);
+ r1 = get_var(cu, J_INT);
+ r2 = get_var(cu, J_INT);
bb = get_basic_block(cu, 0, 3);
@@ -80,8 +80,8 @@ void test_variable_range_spans_two_basic_blocks(void)
struct insn *insn[4];
cu = compilation_unit_alloc(&method);
- r1 = get_var(cu);
- r2 = get_var(cu);
+ r1 = get_var(cu, J_INT);
+ r2 = get_var(cu, J_INT);
bb1 = get_basic_block(cu, 0, 2);
bb2 = get_basic_block(cu, 2, 4);
diff --git a/test/jit/load-store-bc-test.c b/test/jit/load-store-bc-test.c
index b1ec9d1..84addae 100644
--- a/test/jit/load-store-bc-test.c
+++ b/test/jit/load-store-bc-test.c
@@ -511,7 +511,7 @@ static void __assert_convert_store(unsigned char *code,
bb = alloc_simple_bb(code, code_size);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
stack_push(bb->mimic_stack, temporary_expr(J_INT, NULL, temporary));
convert_to_ir(bb->b_parent);
diff --git a/test/jit/object-bc-test.c b/test/jit/object-bc-test.c
index b56ae91..4be71f9 100644
--- a/test/jit/object-bc-test.c
+++ b/test/jit/object-bc-test.c
@@ -343,7 +343,7 @@ static void assert_convert_array_store(enum vm_type
expected_type,
arrayref_expr = value_expr(J_REFERENCE, arrayref);
index_expr = value_expr(J_INT, index);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
expr = temporary_expr(expected_type, NULL, temporary);
stack_push(bb->mimic_stack, arrayref_expr);
diff --git a/test/jit/spill-reload-test.c b/test/jit/spill-reload-test.c
index 04f4c90..bf0abba 100644
--- a/test/jit/spill-reload-test.c
+++ b/test/jit/spill-reload-test.c
@@ -58,8 +58,8 @@ void
test_spill_insn_is_inserted_at_the_end_of_the_interval_if_necessary(void)
struct insn *insn;
cu = compilation_unit_alloc(&method);
- r1 = get_var(cu);
- r2 = get_var(cu);
+ r1 = get_var(cu, J_INT);
+ r2 = get_var(cu, J_INT);
insn_array[0] = arithmetic_insn(INSN_ADD, r1, r1, r1);
insn_array[1] = arithmetic_insn(INSN_ADD, r2, r2, r2);
@@ -104,8 +104,8 @@ void
test_reload_insn_is_inserted_at_the_beginning_of_the_interval_if_necessary(
struct insn *insn;
cu = compilation_unit_alloc(&method);
- r1 = get_var(cu);
- r2 = get_var(cu);
+ r1 = get_var(cu, J_INT);
+ r2 = get_var(cu, J_INT);
insn_array[0] = arithmetic_insn(INSN_ADD, r1, r1, r1);
insn_array[1] = arithmetic_insn(INSN_ADD, r2, r2, r2);
@@ -151,7 +151,7 @@ void test_empty_interval_is_never_spilled(void)
cu = compilation_unit_alloc(&method);
bb = get_basic_block(cu, 0, 2);
- r1 = get_var(cu);
+ r1 = get_var(cu, J_INT);
r1->interval->need_spill = true;
compute_insn_positions(cu);
diff --git a/test/jit/typeconv-bc-test.c b/test/jit/typeconv-bc-test.c
index 6243da9..f409f4d 100644
--- a/test/jit/typeconv-bc-test.c
+++ b/test/jit/typeconv-bc-test.c
@@ -25,7 +25,7 @@ static void assert_conversion_mimic_stack(unsigned char opc,
struct basic_block *bb;
bb = __alloc_simple_bb(&method);
- temporary = get_var(bb->b_parent);
+ temporary = get_var(bb->b_parent, J_INT);
expression = temporary_expr(from_type, NULL, temporary);
stack_push(bb->mimic_stack, expression);
convert_to_ir(bb->b_parent);
--
1.6.0.6
------------------------------------------------------------------------------
Enter the BlackBerry Developer Challenge
This is your chance to win up to $100,000 in prizes! For a limited time,
vendors submitting new applications to BlackBerry App World(TM) will have
the opportunity to enter the BlackBerry Developer Challenge. See full prize
details at: http://p.sf.net/sfu/Challenge
_______________________________________________
Jatovm-devel mailing list
Jatovm-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/jatovm-devel
