{SCF_OP_3AC_ASSIGN_ARRAY_INDEX, "array_index="},
{SCF_OP_3AC_ASSIGN_POINTER, "pointer="},
- {SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE, "dereference+="},
- {SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX, "array_index+="},
- {SCF_OP_3AC_ADD_ASSIGN_POINTER, "pointer+="},
-
- {SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE, "dereference-="},
- {SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX, "array_index-="},
- {SCF_OP_3AC_SUB_ASSIGN_POINTER, "pointer-="},
-
- {SCF_OP_3AC_AND_ASSIGN_DEREFERENCE, "dereference&="},
- {SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX, "array_index&="},
- {SCF_OP_3AC_AND_ASSIGN_POINTER, "pointer&="},
-
- {SCF_OP_3AC_OR_ASSIGN_DEREFERENCE, "dereference|="},
- {SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX, "array_index|="},
- {SCF_OP_3AC_OR_ASSIGN_POINTER, "pointer|="},
-
- {SCF_OP_3AC_INC_DEREFERENCE, "++dereference"},
- {SCF_OP_3AC_INC_ARRAY_INDEX, "++array_index"},
- {SCF_OP_3AC_INC_POINTER, "++pointer"},
-
- {SCF_OP_3AC_DEC_DEREFERENCE, "--dereference"},
- {SCF_OP_3AC_DEC_ARRAY_INDEX, "--array_index"},
- {SCF_OP_3AC_DEC_POINTER, "--pointer"},
-
- {SCF_OP_3AC_INC_POST_DEREFERENCE, "dereference++"},
- {SCF_OP_3AC_INC_POST_ARRAY_INDEX, "array_index++"},
- {SCF_OP_3AC_INC_POST_POINTER, "pointer++"},
-
- {SCF_OP_3AC_DEC_POST_DEREFERENCE, "dereference--"},
- {SCF_OP_3AC_DEC_POST_ARRAY_INDEX, "array_index--"},
- {SCF_OP_3AC_DEC_POST_POINTER, "pointer--"},
-
{SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX, "&array_index"},
{SCF_OP_3AC_ADDRESS_OF_POINTER, "&pointer"},
};
switch (c->op->type) {
case SCF_OP_ARRAY_INDEX:
case SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX:
- case SCF_OP_3AC_INC_POST_ARRAY_INDEX:
- case SCF_OP_3AC_DEC_POST_ARRAY_INDEX:
case SCF_OP_VA_START:
case SCF_OP_VA_ARG:
n_operands0 = 3;
SCF_OP_3AC_DEC,
SCF_OP_3AC_ASSIGN_DEREFERENCE, // left value, *p = expr
- SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE,
- SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE,
- SCF_OP_3AC_AND_ASSIGN_DEREFERENCE,
- SCF_OP_3AC_OR_ASSIGN_DEREFERENCE,
- SCF_OP_3AC_INC_DEREFERENCE,
- SCF_OP_3AC_DEC_DEREFERENCE,
- SCF_OP_3AC_INC_POST_DEREFERENCE,
- SCF_OP_3AC_DEC_POST_DEREFERENCE,
SCF_OP_3AC_ASSIGN_ARRAY_INDEX, // left value, a[0] = expr
- SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX,
- SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX,
- SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX,
- SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX,
- SCF_OP_3AC_INC_ARRAY_INDEX,
- SCF_OP_3AC_DEC_ARRAY_INDEX,
- SCF_OP_3AC_INC_POST_ARRAY_INDEX,
- SCF_OP_3AC_DEC_POST_ARRAY_INDEX,
SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX,
// 97
SCF_OP_3AC_ASSIGN_POINTER, // left value, p->a = expr
- SCF_OP_3AC_ADD_ASSIGN_POINTER,
- SCF_OP_3AC_SUB_ASSIGN_POINTER,
- SCF_OP_3AC_AND_ASSIGN_POINTER,
- SCF_OP_3AC_OR_ASSIGN_POINTER,
- SCF_OP_3AC_INC_POINTER,
- SCF_OP_3AC_DEC_POINTER,
- SCF_OP_3AC_INC_POST_POINTER,
- SCF_OP_3AC_DEC_POST_POINTER,
SCF_OP_3AC_ADDRESS_OF_POINTER,
SCF_OP_3AC_JZ, // jz
static int scf_type_is_assign_dereference(int type)
{
- return type >= SCF_OP_3AC_ASSIGN_DEREFERENCE && type <= SCF_OP_3AC_DEC_POST_DEREFERENCE;
+ return SCF_OP_3AC_ASSIGN_DEREFERENCE == type;
}
static int scf_type_is_assign_array_index(int type)
{
- return type >= SCF_OP_3AC_ASSIGN_ARRAY_INDEX && type <= SCF_OP_3AC_DEC_POST_ARRAY_INDEX;
+ return SCF_OP_3AC_ASSIGN_ARRAY_INDEX == type;
}
static int scf_type_is_assign_pointer(int type)
{
- return type >= SCF_OP_3AC_ASSIGN_POINTER && type <= SCF_OP_3AC_DEC_POST_POINTER;
+ return SCF_OP_3AC_ASSIGN_POINTER == type;
}
static int scf_type_is_signed(int type)
return _scf_3ac_code_N(h, SCF_OP_3AC_##op##_DEREFERENCE, NULL, nodes, nb_nodes); \
}
SCF_DAG_ASSIGN_DEREFERENCE(assign, ASSIGN);
-SCF_DAG_ASSIGN_DEREFERENCE(add_assign, ADD_ASSIGN);
-SCF_DAG_ASSIGN_DEREFERENCE(sub_assign, SUB_ASSIGN);
-SCF_DAG_ASSIGN_DEREFERENCE(and_assign, AND_ASSIGN);
-SCF_DAG_ASSIGN_DEREFERENCE(or_assign, OR_ASSIGN);
-SCF_DAG_ASSIGN_DEREFERENCE(inc, INC);
-SCF_DAG_ASSIGN_DEREFERENCE(dec, DEC);
#define SCF_DAG_ASSIGN_ARRAY_INDEX(name, op) \
static int _scf_dag_op_##name##_array_index(scf_list_t* h, scf_dag_node_t* parent, scf_dag_node_t** nodes, int nb_nodes) \
return _scf_3ac_code_N(h, SCF_OP_3AC_##op##_ARRAY_INDEX, NULL, nodes, nb_nodes); \
}
SCF_DAG_ASSIGN_ARRAY_INDEX(assign, ASSIGN);
-SCF_DAG_ASSIGN_ARRAY_INDEX(add_assign, ADD_ASSIGN);
-SCF_DAG_ASSIGN_ARRAY_INDEX(sub_assign, SUB_ASSIGN);
-SCF_DAG_ASSIGN_ARRAY_INDEX(and_assign, AND_ASSIGN);
-SCF_DAG_ASSIGN_ARRAY_INDEX(or_assign, OR_ASSIGN);
-SCF_DAG_ASSIGN_ARRAY_INDEX(inc, INC);
-SCF_DAG_ASSIGN_ARRAY_INDEX(dec, DEC);
#define SCF_DAG_ASSIGN_POINTER(name, op) \
static int _scf_dag_op_##name##_pointer(scf_list_t* h, scf_dag_node_t* parent, scf_dag_node_t** nodes, int nb_nodes) \
return _scf_3ac_code_N(h, SCF_OP_3AC_##op##_POINTER, NULL, nodes, nb_nodes); \
}
SCF_DAG_ASSIGN_POINTER(assign, ASSIGN);
-SCF_DAG_ASSIGN_POINTER(add_assign, ADD_ASSIGN);
-SCF_DAG_ASSIGN_POINTER(sub_assign, SUB_ASSIGN);
-SCF_DAG_ASSIGN_POINTER(and_assign, AND_ASSIGN);
-SCF_DAG_ASSIGN_POINTER(or_assign, OR_ASSIGN);
-SCF_DAG_ASSIGN_POINTER(inc, INC);
-SCF_DAG_ASSIGN_POINTER(dec, DEC);
static int _scf_dag_op_return(scf_list_t* h, scf_dag_node_t* parent, scf_dag_node_t** nodes, int nb_nodes)
{
{SCF_OP_OR_ASSIGN, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_or_assign},
{SCF_OP_3AC_ASSIGN_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_assign_array_index},
- {SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_add_assign_array_index},
- {SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_sub_assign_array_index},
- {SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_and_assign_array_index},
- {SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_or_assign_array_index},
- {SCF_OP_3AC_INC_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_inc_array_index},
- {SCF_OP_3AC_DEC_ARRAY_INDEX, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_dec_array_index},
-
{SCF_OP_3AC_ASSIGN_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_assign_pointer},
- {SCF_OP_3AC_ADD_ASSIGN_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_add_assign_pointer},
- {SCF_OP_3AC_SUB_ASSIGN_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_sub_assign_pointer},
- {SCF_OP_3AC_AND_ASSIGN_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_and_assign_pointer},
- {SCF_OP_3AC_OR_ASSIGN_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_or_assign_pointer},
- {SCF_OP_3AC_INC_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_inc_pointer},
- {SCF_OP_3AC_DEC_POINTER, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_dec_pointer},
-
{SCF_OP_3AC_ASSIGN_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_assign_dereference},
- {SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_add_assign_dereference},
- {SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_sub_assign_dereference},
- {SCF_OP_3AC_AND_ASSIGN_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_and_assign_dereference},
- {SCF_OP_3AC_OR_ASSIGN_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_or_assign_dereference},
- {SCF_OP_3AC_INC_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_inc_dereference},
- {SCF_OP_3AC_DEC_DEREFERENCE, SCF_OP_ASSOCIATIVITY_RIGHT, _scf_dag_op_dec_dereference},
};
scf_dag_operator_t* scf_dag_operator_find(int type)
#endif
scf_dag_operator_t* op = scf_dag_operator_find(node->type);
if (!op) {
- scf_loge("node->type: %d, %d\n", node->type, SCF_OP_3AC_DEC_POINTER);
+ scf_loge("node->type: %d\n", node->type);
if (node->var && node->var->w)
scf_loge("node->var: %s\n", node->var->w->text->data);
return -1;
}
if (h(ast, node->nodes, node->nb_nodes, d) < 0) {
- scf_loge("\n");
ast->current_block = up;
return -1;
}
ast->current_block = (scf_block_t*)f;
d->branch_ops = local_branch_ops; // use local_branch_ops, because branch code should NOT jmp over the function block
- if (_scf_op_block(ast, f->node.nodes, f->node.nb_nodes, d) < 0) {
- scf_loge("\n");
+ if (_scf_op_block(ast, f->node.nodes, f->node.nb_nodes, d) < 0)
return -1;
- }
scf_list_t* next;
scf_3ac_operand_t* dst;
scf_handler_data_t* d = data;
int ret = _scf_expr_calculate_internal(ast, nodes[0], d);
- if (ret < 0) {
- scf_loge("\n");
+ if (ret < 0)
return -1;
- }
#endif
return 0;
}
srcs[0] = child->nodes[0];
srcs[1] = child->nodes[1];
+ scf_variable_t* v = _scf_operand_get(srcs[1]);
+ if (v->bit_size > 0) {
+ scf_loge("can't pointer to the bit member '%s' of a struct, file: %s, line: %d\n",
+ v->w->text->data, parent->w->file->data, parent->w->line);
+ return -EINVAL;
+ }
+
return _scf_3ac_code_N(d->_3ac_list_head, SCF_OP_3AC_ADDRESS_OF_POINTER, parent, srcs, 2);
}
{
scf_node_t* right = *pright;
- if (_scf_expr_calculate_internal(ast, right, d) < 0) {
- scf_loge("\n");
+ if (_scf_expr_calculate_internal(ast, right, d) < 0)
return -1;
- }
if (scf_type_is_assign(right->type)) {
right = right->nodes[0];
right->_3ac_done = 0;
- if (_scf_expr_calculate_internal(ast, right, d) < 0) {
- scf_loge("\n");
+ if (_scf_expr_calculate_internal(ast, right, d) < 0)
return -1;
- }
} else {
while (SCF_OP_EXPR == right->type)
while (SCF_OP_EXPR == node0->type) \
node0 = node0->nodes[0]; \
\
- int is_float = scf_type_is_float(v1->type) && 0 == v1->nb_pointers; \
- if (is_float) { \
- if (_scf_expr_calculate_internal(ast, node0, d) < 0) { \
- scf_loge("\n"); \
- return -1; \
- } \
- \
- if ( _scf_3ac_code_2(d->_3ac_list_head, parent->type, node0, node1) < 0) { \
- scf_loge("\n"); \
- return -1; \
- } \
- \
- switch (node0->type) { \
- case SCF_OP_DEREFERENCE: \
- return _scf_op_left_value(ast, SCF_OP_3AC_ASSIGN_DEREFERENCE, node0, node0, d); \
- break; \
- case SCF_OP_ARRAY_INDEX: \
- return _scf_op_left_value_array_index(ast, SCF_OP_3AC_ASSIGN_ARRAY_INDEX, node0, node0, d); \
- break; \
- case SCF_OP_POINTER: \
- return _scf_op_left_value(ast, SCF_OP_3AC_ASSIGN_POINTER, node0, node0, d); \
- break; \
- default: \
- break; \
- }; \
- \
- return 0; \
+ if (_scf_expr_calculate_internal(ast, node0, d) < 0) { \
+ scf_loge("\n"); \
+ return -1; \
+ } \
+ \
+ if ( _scf_3ac_code_2(d->_3ac_list_head, parent->type, node0, node1) < 0) { \
+ scf_loge("\n"); \
+ return -1; \
} \
\
switch (node0->type) { \
case SCF_OP_DEREFERENCE: \
- return _scf_op_left_value(ast, SCF_OP_3AC_##op##_ASSIGN_DEREFERENCE, node0, node1, d); \
+ return _scf_op_left_value(ast, SCF_OP_3AC_ASSIGN_DEREFERENCE, node0, node0, d); \
break; \
case SCF_OP_ARRAY_INDEX: \
- return _scf_op_left_value_array_index(ast, SCF_OP_3AC_##op##_ASSIGN_ARRAY_INDEX, node0, node1, d); \
+ return _scf_op_left_value_array_index(ast, SCF_OP_3AC_ASSIGN_ARRAY_INDEX, node0, node0, d); \
break; \
case SCF_OP_POINTER: \
- return _scf_op_left_value(ast, SCF_OP_3AC_##op##_ASSIGN_POINTER, node0, node1, d); \
+ return _scf_op_left_value(ast, SCF_OP_3AC_ASSIGN_POINTER, node0, node0, d); \
break; \
default: \
break; \
}; \
\
- return _scf_3ac_code_2(d->_3ac_list_head, SCF_OP_##op##_ASSIGN, node0, node1); \
+ return 0; \
}
SCF_OP_BINARY_ASSIGN(add, ADD)
SCF_OP_BINARY_ASSIGN(and, AND)
SCF_OP_BINARY_ASSIGN(or, OR)
-#define SCF_OP_BINARY_ASSIGN2(name, op) \
-static int _scf_op_##name##_assign(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) \
+SCF_OP_BINARY_ASSIGN(shl, SHL)
+SCF_OP_BINARY_ASSIGN(shr, SHR)
+SCF_OP_BINARY_ASSIGN(mul, MUL)
+SCF_OP_BINARY_ASSIGN(div, DIV)
+SCF_OP_BINARY_ASSIGN(mod, MOD)
+
+#define SCF_OP_UNARY_ASSIGN(name, op) \
+static int __scf_op_##name(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) \
{ \
- assert(2 == nb_nodes); \
+ assert(1 == nb_nodes); \
scf_handler_data_t* d = data; \
\
- scf_node_t* parent = nodes[0]->parent; \
- scf_node_t* node0 = nodes[0]; \
- scf_node_t* node1 = nodes[1]; \
- scf_variable_t* v1 = _scf_operand_get(nodes[1]); \
- \
- if ( _scf_op_right_value(ast, &node1, d) < 0) \
- return -1; \
+ scf_node_t* node0 = nodes[0]; \
\
while (SCF_OP_EXPR == node0->type) \
node0 = node0->nodes[0]; \
return -1; \
} \
\
- if ( _scf_3ac_code_2(d->_3ac_list_head, parent->type, node0, node1) < 0) { \
+ if (_scf_3ac_code_1(d->_3ac_list_head, SCF_OP_3AC_##op, node0) < 0) { \
scf_loge("\n"); \
return -1; \
} \
\
return 0; \
}
-SCF_OP_BINARY_ASSIGN2(shl, SHL)
-SCF_OP_BINARY_ASSIGN2(shr, SHR)
-SCF_OP_BINARY_ASSIGN2(mul, MUL)
-SCF_OP_BINARY_ASSIGN2(div, DIV)
-SCF_OP_BINARY_ASSIGN2(mod, MOD)
-
-#define SCF_OP_UNARY_ASSIGN(name, op) \
-static int __scf_op_##name(scf_ast_t* ast, scf_node_t** nodes, int nb_nodes, void* data) \
-{ \
- assert(1 == nb_nodes); \
- scf_handler_data_t* d = data; \
- \
- scf_node_t* node0 = nodes[0]; \
- \
- while (SCF_OP_EXPR == node0->type) \
- node0 = node0->nodes[0]; \
- \
- switch (node0->type) { \
- case SCF_OP_DEREFERENCE: \
- return _scf_op_left_value(ast, SCF_OP_3AC_##op##_DEREFERENCE, node0, NULL, d); \
- break; \
- case SCF_OP_ARRAY_INDEX: \
- return _scf_op_left_value_array_index(ast, SCF_OP_3AC_##op##_ARRAY_INDEX, node0, NULL, d); \
- break; \
- case SCF_OP_POINTER: \
- return _scf_op_left_value(ast, SCF_OP_3AC_##op##_POINTER, node0, NULL, d); \
- break; \
- default: \
- break; \
- }; \
- \
- return _scf_3ac_code_1(d->_3ac_list_head, SCF_OP_3AC_##op, node0); \
-}
SCF_OP_UNARY_ASSIGN(inc, INC)
SCF_OP_UNARY_ASSIGN(dec, DEC)
case SCF_OP_3AC_ASSIGN_DEREFERENCE:
c->op = scf_3ac_find_operator(SCF_OP_ASSIGN);
break;
-
- case SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_ADD_ASSIGN);
- break;
- case SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_SUB_ASSIGN);
- break;
-
- case SCF_OP_3AC_AND_ASSIGN_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_AND_ASSIGN);
- break;
- case SCF_OP_3AC_OR_ASSIGN_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_OR_ASSIGN);
- break;
-
- case SCF_OP_3AC_INC_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_INC);
- break;
- case SCF_OP_3AC_DEC_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_DEC);
- break;
- case SCF_OP_3AC_INC_POST_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_INC_POST);
- break;
- case SCF_OP_3AC_DEC_POST_DEREFERENCE:
- c->op = scf_3ac_find_operator(SCF_OP_DEC_POST);
- break;
-
default:
scf_loge("\n");
return -1;
v2->data_size = v->data_size;
v2->offset = v->offset;
+ v2->bit_offset = v->bit_offset;
+ v2->bit_size = v->bit_size;
+
if (scf_variable_is_struct(v) || scf_variable_is_array(v)) {
int size = scf_variable_size(v);
int size;
int data_size;
+ int bit_offset;
+ int bit_size;
+
int offset;
int bp_offset; // offset based on RBP / EBP register
int sp_offset; // offset based on RSP / ESP register
--- /dev/null
+int printf(const char* fmt, ...);
+
+struct S
+{
+ uint32_t a:3;
+ uint16_t b:13;
+ uint8_t c:5;
+};
+
+int main()
+{
+ S s;
+
+ s.a = 1;
+ s.b = 2;
+ s.c = 3;
+
+// uint32_t* p = &s.a;
+
+ printf("%d, %d, %d\n", s.a, s.b, s.c);
+ return 0;
+}
return -EINVAL;
}
-static int _eda_inst_and_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
-{
- if (!c->srcs || c->srcs->size != 4)
- return -EINVAL;
-
- scf_eda_context_t* eda = ctx->priv;
- scf_function_t* f = eda->f;
-
- scf_3ac_operand_t* base = c->srcs->data[0];
- scf_3ac_operand_t* index = c->srcs->data[1];
- scf_3ac_operand_t* scale = c->srcs->data[2];
- scf_3ac_operand_t* src = c->srcs->data[3];
-
- if (!base || !base->dag_node)
- return -EINVAL;
-
- if (!index || !index->dag_node)
- return -EINVAL;
-
- if (!scale || !scale->dag_node)
- return -EINVAL;
-
- if (!src || !src->dag_node)
- return -EINVAL;
-
- return -EINVAL;
-}
-
-static int _eda_inst_or_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
-{
- if (!c->srcs || c->srcs->size != 4)
- return -EINVAL;
-
- scf_eda_context_t* eda = ctx->priv;
- scf_function_t* f = eda->f;
-
- scf_3ac_operand_t* base = c->srcs->data[0];
- scf_3ac_operand_t* index = c->srcs->data[1];
- scf_3ac_operand_t* scale = c->srcs->data[2];
- scf_3ac_operand_t* src = c->srcs->data[3];
-
- if (!base || !base->dag_node)
- return -EINVAL;
-
- if (!index || !index->dag_node)
- return -EINVAL;
-
- if (!scale || !scale->dag_node)
- return -EINVAL;
-
- if (!src || !src->dag_node)
- return -EINVAL;
-
- return -EINVAL;
-}
-
static int _eda_inst_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
{
if (!c->dsts || c->dsts->size != 1)
[SCF_OP_3AC_RESAVE] = _eda_inst_save_handler,
[SCF_OP_3AC_RELOAD] = _eda_inst_reload_handler,
- [SCF_OP_3AC_ASSIGN_ARRAY_INDEX] = _eda_inst_assign_array_index_handler,
- [SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX] = _eda_inst_and_assign_array_index_handler,
- [SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX] = _eda_inst_or_assign_array_index_handler,
+ [SCF_OP_3AC_ASSIGN_ARRAY_INDEX] = _eda_inst_assign_array_index_handler,
};
eda_inst_handler_pt scf_eda_find_inst_handler(const int op_type)
[SCF_OP_3AC_ASSIGN_ARRAY_INDEX ] = _risc_inst_assign_array_index_handler,
[SCF_OP_3AC_ASSIGN_POINTER ] = _risc_inst_assign_pointer_handler,
- [SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE] = _risc_inst_add_assign_dereference_handler,
- [SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX] = _risc_inst_add_assign_array_index_handler,
- [SCF_OP_3AC_ADD_ASSIGN_POINTER ] = _risc_inst_add_assign_pointer_handler,
-
- [SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE] = _risc_inst_sub_assign_dereference_handler,
- [SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX] = _risc_inst_sub_assign_array_index_handler,
- [SCF_OP_3AC_SUB_ASSIGN_POINTER ] = _risc_inst_sub_assign_pointer_handler,
-
- [SCF_OP_3AC_AND_ASSIGN_DEREFERENCE] = _risc_inst_and_assign_dereference_handler,
- [SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX] = _risc_inst_and_assign_array_index_handler,
- [SCF_OP_3AC_AND_ASSIGN_POINTER ] = _risc_inst_and_assign_pointer_handler,
-
- [SCF_OP_3AC_OR_ASSIGN_DEREFERENCE ] = _risc_inst_or_assign_dereference_handler,
- [SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX ] = _risc_inst_or_assign_array_index_handler,
- [SCF_OP_3AC_OR_ASSIGN_POINTER ] = _risc_inst_or_assign_pointer_handler,
-
- [SCF_OP_3AC_INC_DEREFERENCE ] = _risc_inst_inc_dereference_handler,
- [SCF_OP_3AC_INC_ARRAY_INDEX ] = _risc_inst_inc_array_index_handler,
- [SCF_OP_3AC_INC_POINTER ] = _risc_inst_inc_pointer_handler,
-
- [SCF_OP_3AC_INC_POST_DEREFERENCE ] = _risc_inst_inc_post_dereference_handler,
- [SCF_OP_3AC_INC_POST_ARRAY_INDEX ] = _risc_inst_inc_post_array_index_handler,
- [SCF_OP_3AC_INC_POST_POINTER ] = _risc_inst_inc_post_pointer_handler,
-
- [SCF_OP_3AC_DEC_DEREFERENCE ] = _risc_inst_dec_dereference_handler,
- [SCF_OP_3AC_DEC_ARRAY_INDEX ] = _risc_inst_dec_array_index_handler,
- [SCF_OP_3AC_DEC_POINTER ] = _risc_inst_dec_pointer_handler,
-
- [SCF_OP_3AC_DEC_POST_DEREFERENCE ] = _risc_inst_dec_post_dereference_handler,
- [SCF_OP_3AC_DEC_POST_ARRAY_INDEX ] = _risc_inst_dec_post_array_index_handler,
- [SCF_OP_3AC_DEC_POST_POINTER ] = _risc_inst_dec_post_pointer_handler,
-
[SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX] = _risc_inst_address_of_array_index_handler,
[SCF_OP_3AC_ADDRESS_OF_POINTER ] = _risc_inst_address_of_pointer_handler,
};
[SCF_OP_3AC_ASSIGN_ARRAY_INDEX ] = _risc_rcg_assign_array_index_handler,
[SCF_OP_3AC_ASSIGN_POINTER ] = _risc_rcg_assign_pointer_handler,
- [SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE] = _risc_rcg_add_assign_dereference_handler,
- [SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX] = _risc_rcg_add_assign_array_index_handler,
- [SCF_OP_3AC_ADD_ASSIGN_POINTER ] = _risc_rcg_add_assign_pointer_handler,
-
- [SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE] = _risc_rcg_sub_assign_dereference_handler,
- [SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX] = _risc_rcg_sub_assign_array_index_handler,
- [SCF_OP_3AC_SUB_ASSIGN_POINTER ] = _risc_rcg_sub_assign_pointer_handler,
-
- [SCF_OP_3AC_AND_ASSIGN_DEREFERENCE] = _risc_rcg_and_assign_dereference_handler,
- [SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX] = _risc_rcg_and_assign_array_index_handler,
- [SCF_OP_3AC_AND_ASSIGN_POINTER ] = _risc_rcg_and_assign_pointer_handler,
-
- [SCF_OP_3AC_OR_ASSIGN_DEREFERENCE ] = _risc_rcg_or_assign_dereference_handler,
- [SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX ] = _risc_rcg_or_assign_array_index_handler,
- [SCF_OP_3AC_OR_ASSIGN_POINTER ] = _risc_rcg_or_assign_pointer_handler,
-
- [SCF_OP_3AC_INC_DEREFERENCE ] = _risc_rcg_inc_dereference_handler,
- [SCF_OP_3AC_INC_ARRAY_INDEX ] = _risc_rcg_inc_array_index_handler,
- [SCF_OP_3AC_INC_POINTER ] = _risc_rcg_inc_pointer_handler,
-
- [SCF_OP_3AC_INC_POST_DEREFERENCE ] = _risc_rcg_inc_post_dereference_handler,
- [SCF_OP_3AC_INC_POST_ARRAY_INDEX ] = _risc_rcg_inc_post_array_index_handler,
- [SCF_OP_3AC_INC_POST_POINTER ] = _risc_rcg_inc_post_pointer_handler,
-
- [SCF_OP_3AC_DEC_DEREFERENCE ] = _risc_rcg_dec_dereference_handler,
- [SCF_OP_3AC_DEC_ARRAY_INDEX ] = _risc_rcg_dec_array_index_handler,
- [SCF_OP_3AC_DEC_POINTER ] = _risc_rcg_dec_pointer_handler,
-
- [SCF_OP_3AC_DEC_POST_DEREFERENCE ] = _risc_rcg_dec_post_dereference_handler,
- [SCF_OP_3AC_DEC_POST_ARRAY_INDEX ] = _risc_rcg_dec_post_array_index_handler,
- [SCF_OP_3AC_DEC_POST_POINTER ] = _risc_rcg_dec_post_pointer_handler,
-
[SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX] = _risc_rcg_address_of_array_index_handler,
[SCF_OP_3AC_ADDRESS_OF_POINTER ] = _risc_rcg_address_of_pointer_handler,
};
int x64_binary_assign(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-int x64_binary_assign_dereference(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-int x64_binary_assign_pointer (scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-int x64_binary_assign_array_index(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-
-int x64_unary_assign_dereference (scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-int x64_unary_assign_pointer (scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-int x64_unary_assign_array_index (scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type);
-
+int x64_assign_dereference(scf_native_t* ctx, scf_3ac_code_t* c);
+int x64_assign_pointer (scf_native_t* ctx, scf_3ac_code_t* c);
+int x64_assign_array_index(scf_native_t* ctx, scf_3ac_code_t* c);
int x64_inst_int_mul(scf_dag_node_t* dst, scf_dag_node_t* src, scf_3ac_code_t* c, scf_function_t* f);
int x64_inst_int_div(scf_dag_node_t* dst, scf_dag_node_t* src, scf_3ac_code_t* c, scf_function_t* f, int mod_flag);
static int _x64_inst_##name##_handler(scf_native_t* ctx, scf_3ac_code_t* c) \
{ \
return x64_binary_assign(ctx, c, SCF_X64_##op); \
-} \
-static int _x64_inst_##name##_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c) \
-{ \
- return x64_binary_assign_pointer(ctx, c, SCF_X64_##op); \
-} \
-static int _x64_inst_##name##_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- return _x64_inst_assign_array_index(ctx, c, SCF_X64_##op);\
-}\
-static int _x64_inst_##name##_dereference_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- return x64_binary_assign_dereference(ctx, c, SCF_X64_##op);\
}
X64_INST_BINARY_ASSIGN(assign, MOV)
X64_INST_BINARY_ASSIGN(and_assign, AND)
X64_INST_BINARY_ASSIGN(or_assign, OR)
+static int _x64_inst_assign_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+ return x64_assign_pointer(ctx, c);
+}
+static int _x64_inst_assign_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+ return _x64_inst_assign_array_index(ctx, c, SCF_X64_MOV);
+}
+static int _x64_inst_assign_dereference_handler(scf_native_t* ctx, scf_3ac_code_t* c)
+{
+ return x64_assign_dereference(ctx, c);
+}
+
#define X64_INST_SHIFT(name, op) \
static int _x64_inst_##name##_handler(scf_native_t* ctx, scf_3ac_code_t* c) \
{ \
X64_INST_SHIFT(shl, SHL)
X64_INST_SHIFT(shr, SHR)
-#define X64_INST_UNARY_ASSIGN(name, op) \
-static int _x64_inst_##name##_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c) \
-{ \
- return x64_unary_assign_pointer(ctx, c, SCF_X64_##op); \
-} \
-static int _x64_inst_##name##_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- return x64_unary_assign_array_index(ctx, c, SCF_X64_##op);\
-}\
-static int _x64_inst_##name##_dereference_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- return x64_unary_assign_dereference(ctx, c, SCF_X64_##op);\
-}
-X64_INST_UNARY_ASSIGN(inc, INC)
-X64_INST_UNARY_ASSIGN(dec, DEC)
-
-#define X64_INST_UNARY_POST_ASSIGN(name, op) \
-static int _x64_inst_##name##_pointer_handler(scf_native_t* ctx, scf_3ac_code_t* c) \
-{ \
- int ret = x64_inst_pointer(ctx, c, 0); \
- if (ret < 0) \
- return ret; \
- return x64_unary_assign_pointer(ctx, c, SCF_X64_##op); \
-} \
-static int _x64_inst_##name##_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- int ret = _x64_inst_array_index_handler(ctx, c); \
- if (ret < 0) \
- return ret; \
- return x64_unary_assign_array_index(ctx, c, SCF_X64_##op);\
-}\
-static int _x64_inst_##name##_dereference_handler(scf_native_t* ctx, scf_3ac_code_t* c)\
-{\
- int ret = x64_inst_dereference(ctx, c); \
- if (ret < 0) \
- return ret; \
- return x64_unary_assign_dereference(ctx, c, SCF_X64_##op);\
-}
-X64_INST_UNARY_POST_ASSIGN(inc_post, INC)
-X64_INST_UNARY_POST_ASSIGN(dec_post, DEC)
-
static int _x64_inst_address_of_array_index_handler(scf_native_t* ctx, scf_3ac_code_t* c)
{
return _x64_inst_array_index(ctx, c, 1);
[SCF_OP_3AC_ASSIGN_ARRAY_INDEX ] = _x64_inst_assign_array_index_handler,
[SCF_OP_3AC_ASSIGN_POINTER ] = _x64_inst_assign_pointer_handler,
- [SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE] = _x64_inst_add_assign_dereference_handler,
- [SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX] = _x64_inst_add_assign_array_index_handler,
- [SCF_OP_3AC_ADD_ASSIGN_POINTER ] = _x64_inst_add_assign_pointer_handler,
-
- [SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE] = _x64_inst_sub_assign_dereference_handler,
- [SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX] = _x64_inst_sub_assign_array_index_handler,
- [SCF_OP_3AC_SUB_ASSIGN_POINTER ] = _x64_inst_sub_assign_pointer_handler,
-
- [SCF_OP_3AC_AND_ASSIGN_DEREFERENCE] = _x64_inst_and_assign_dereference_handler,
- [SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX] = _x64_inst_and_assign_array_index_handler,
- [SCF_OP_3AC_AND_ASSIGN_POINTER ] = _x64_inst_and_assign_pointer_handler,
-
- [SCF_OP_3AC_OR_ASSIGN_DEREFERENCE ] = _x64_inst_or_assign_dereference_handler,
- [SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX ] = _x64_inst_or_assign_array_index_handler,
- [SCF_OP_3AC_OR_ASSIGN_POINTER ] = _x64_inst_or_assign_pointer_handler,
-
- [SCF_OP_3AC_INC_DEREFERENCE ] = _x64_inst_inc_dereference_handler,
- [SCF_OP_3AC_INC_ARRAY_INDEX ] = _x64_inst_inc_array_index_handler,
- [SCF_OP_3AC_INC_POINTER ] = _x64_inst_inc_pointer_handler,
-
- [SCF_OP_3AC_INC_POST_DEREFERENCE ] = _x64_inst_inc_post_dereference_handler,
- [SCF_OP_3AC_INC_POST_ARRAY_INDEX ] = _x64_inst_inc_post_array_index_handler,
- [SCF_OP_3AC_INC_POST_POINTER ] = _x64_inst_inc_post_pointer_handler,
-
- [SCF_OP_3AC_DEC_DEREFERENCE ] = _x64_inst_dec_dereference_handler,
- [SCF_OP_3AC_DEC_ARRAY_INDEX ] = _x64_inst_dec_array_index_handler,
- [SCF_OP_3AC_DEC_POINTER ] = _x64_inst_dec_pointer_handler,
-
- [SCF_OP_3AC_DEC_POST_DEREFERENCE ] = _x64_inst_dec_post_dereference_handler,
- [SCF_OP_3AC_DEC_POST_ARRAY_INDEX ] = _x64_inst_dec_post_array_index_handler,
- [SCF_OP_3AC_DEC_POST_POINTER ] = _x64_inst_dec_post_pointer_handler,
-
[SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX] = _x64_inst_address_of_array_index_handler,
[SCF_OP_3AC_ADDRESS_OF_POINTER ] = _x64_inst_address_of_pointer_handler,
};
return 0;
}
-static int _binary_assign_sib(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type, int nb_srcs, x64_sib_fill_pt fill)
-{
- if (!c->srcs || c->srcs->size != nb_srcs) {
- scf_loge("\n");
- return -EINVAL;
- }
-
- scf_x64_context_t* x64 = ctx->priv;
- scf_function_t* f = x64->f;
-
- scf_3ac_operand_t* base = c->srcs->data[0];
- scf_3ac_operand_t* index = c->srcs->data[1];
- scf_3ac_operand_t* src = c->srcs->data[c->srcs->size - 1];
-
- if (!base || !base->dag_node)
- return -EINVAL;
-
- if (!index || !index->dag_node)
- return -EINVAL;
-
- if (!src || !src->dag_node)
- return -EINVAL;
-
- scf_variable_t* b = base->dag_node->var;
- assert(b->nb_pointers > 0 || b->nb_dimentions > 0 || b->type >= SCF_STRUCT);
-
- if (!c->instructions) {
- c->instructions = scf_vector_alloc();
- if (!c->instructions)
- return -ENOMEM;
- }
-
- scf_variable_t* v = src->dag_node->var;
- x64_sib_t sib = {0};
-
- int ret = fill(&sib, base->dag_node, index->dag_node, c, f);
- if (ret < 0)
- return ret;
-
- int is_float = scf_variable_float(v);
- if (is_float)
- return _binary_assign_sib_float(sib.base, sib.index, sib.scale, sib.disp, src->dag_node, c, f, OpCode_type);
-
- return _binary_assign_sib_int(&sib, src->dag_node, c, f, OpCode_type);
-}
-
static int _binary_SIB2G(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type, int nb_srcs, x64_sib_fill_pt fill)
{
if (!c->dsts || c->dsts->size != 1)
return x64_inst_op2(OpCode_type, dst->dag_node, src->dag_node, c, f);
}
-int x64_binary_assign_dereference(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type)
+int x64_assign_dereference(scf_native_t* ctx, scf_3ac_code_t* c)
{
- return _binary_assign_sib(ctx, c, OpCode_type, 2, x64_dereference_reg);
+ if (!c->srcs || c->srcs->size != 2) {
+ scf_loge("\n");
+ return -EINVAL;
+ }
+
+ scf_x64_context_t* x64 = ctx->priv;
+ scf_function_t* f = x64->f;
+ scf_3ac_operand_t* base = c->srcs->data[0];
+ scf_3ac_operand_t* src = c->srcs->data[1];
+
+ if (!base || !base->dag_node)
+ return -EINVAL;
+
+ if (!src || !src->dag_node)
+ return -EINVAL;
+
+ scf_variable_t* b = base->dag_node->var;
+ assert(b->nb_pointers > 0 || b->nb_dimentions > 0 || b->type >= SCF_STRUCT);
+
+ if (!c->instructions) {
+ c->instructions = scf_vector_alloc();
+ if (!c->instructions)
+ return -ENOMEM;
+ }
+
+ scf_variable_t* v = src->dag_node->var;
+ x64_sib_t sib = {0};
+
+ int ret = x64_dereference_reg(&sib, base->dag_node, NULL, c, f);
+ if (ret < 0)
+ return ret;
+
+ int is_float = scf_variable_float(v);
+ if (is_float)
+ return _binary_assign_sib_float(sib.base, sib.index, sib.scale, sib.disp, src->dag_node, c, f, SCF_X64_MOV);
+
+ return _binary_assign_sib_int(&sib, src->dag_node, c, f, SCF_X64_MOV);
}
-int x64_inst_dereference(scf_native_t* ctx, scf_3ac_code_t* c)
+int x64_assign_pointer(scf_native_t* ctx, scf_3ac_code_t* c)
{
- return _binary_SIB2G(ctx, c, SCF_X64_MOV, 1, x64_dereference_reg);
+ if (!c->srcs || c->srcs->size != 3) {
+ scf_loge("\n");
+ return -EINVAL;
+ }
+
+ scf_x64_context_t* x64 = ctx->priv;
+ scf_function_t* f = x64->f;
+ scf_3ac_operand_t* base = c->srcs->data[0];
+ scf_3ac_operand_t* member = c->srcs->data[1];
+ scf_3ac_operand_t* src = c->srcs->data[2];
+
+ if (!base || !base->dag_node)
+ return -EINVAL;
+
+ if (!member || !member->dag_node)
+ return -EINVAL;
+
+ if (!src || !src->dag_node)
+ return -EINVAL;
+
+ scf_variable_t* b = base->dag_node->var;
+ scf_variable_t* vm = member->dag_node->var;
+ scf_variable_t* vs = src->dag_node->var;
+ scf_register_t* rs = NULL;
+ scf_register_t* r = NULL;
+ x64_sib_t sib = {0};
+
+ assert(b->nb_pointers > 0 || b->nb_dimentions > 0 || b->type >= SCF_STRUCT);
+
+ if (!c->instructions) {
+ c->instructions = scf_vector_alloc();
+ if (!c->instructions)
+ return -ENOMEM;
+ }
+
+ int ret = x64_pointer_reg(&sib, base->dag_node, member->dag_node, c, f);
+ if (ret < 0)
+ return ret;
+
+ int is_float = scf_variable_float(vs);
+ if (is_float)
+ return _binary_assign_sib_float(sib.base, sib.index, sib.scale, sib.disp, src->dag_node, c, f, SCF_X64_MOV);
+
+ int dsize = sib.size;
+ int vsize = x64_variable_size(vs);
+
+ assert(dsize <= vsize);
+
+ if (0 == src->dag_node->color)
+ src->dag_node->color = -1;
+
+ X64_SELECT_REG_CHECK(&rs, src->dag_node, c, f, 1);
+
+ rs = x64_find_register_color_bytes(rs->color, dsize);
+
+ scf_instruction_t* inst;
+ scf_x64_OpCode_t* mov;
+ scf_x64_OpCode_t* shl;
+ scf_x64_OpCode_t* shr;
+ scf_x64_OpCode_t* and;
+ scf_x64_OpCode_t* push;
+ scf_x64_OpCode_t* pop;
+
+ mov = x64_find_OpCode(SCF_X64_MOV, dsize, dsize, SCF_X64_G2E);
+
+ if (vm->bit_size > 0) {
+ uint64_t mask = ((1ULL << vm->bit_size) - 1) << vm->bit_offset;
+ mask = ~mask;
+
+ push = x64_find_OpCode(SCF_X64_PUSH, 8, 8, SCF_X64_G);
+ pop = x64_find_OpCode(SCF_X64_POP, 8, 8, SCF_X64_G);
+ mov = x64_find_OpCode(SCF_X64_MOV, dsize, dsize, SCF_X64_I2G);
+ and = x64_find_OpCode(SCF_X64_AND, dsize, dsize, SCF_X64_G2E);
+
+ r = x64_find_register_color_bytes(rs->color, 8);
+ inst = x64_make_inst_G(push, r);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+
+ inst = x64_make_inst_I2G(mov, rs, (uint8_t*)&mask, dsize);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+
+ if (sib.index)
+ inst = x64_make_inst_G2SIB(and, sib.base, sib.index, sib.scale, sib.disp, rs);
+ else
+ inst = x64_make_inst_G2P(and, sib.base, sib.disp, rs);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+
+ inst = x64_make_inst_G(pop, r);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+
+ int imm = (rs->bytes << 3) - vm->bit_size;
+ assert(imm > 0);
+
+ shl = x64_find_OpCode(SCF_X64_SHL, 1, rs->bytes, SCF_X64_I2E);
+ shr = x64_find_OpCode(SCF_X64_SHR, 1, rs->bytes, SCF_X64_I2E);
+
+ inst = x64_make_inst_I2E(shl, rs, (uint8_t*)&imm, 1);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+
+ imm -= vm->bit_offset;
+ assert(imm >= 0);
+
+ if (imm > 0) {
+ inst = x64_make_inst_I2E(shr, rs, (uint8_t*)&imm, 1);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+ }
+
+ mov = x64_find_OpCode(SCF_X64_OR, dsize, dsize, SCF_X64_G2E);
+ }
+
+ if (!mov) {
+ scf_loge("\n");
+ return -EINVAL;
+ }
+
+ if (sib.index)
+ inst = x64_make_inst_G2SIB(mov, sib.base, sib.index, sib.scale, sib.disp, rs);
+ else
+ inst = x64_make_inst_G2P(mov, sib.base, sib.disp, rs);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+ return 0;
}
-int x64_binary_assign_pointer(scf_native_t* ctx, scf_3ac_code_t* c, int OpCode_type)
+int x64_inst_dereference(scf_native_t* ctx, scf_3ac_code_t* c)
{
- return _binary_assign_sib(ctx, c, OpCode_type, 3, x64_pointer_reg);
+ return _binary_SIB2G(ctx, c, SCF_X64_MOV, 1, x64_dereference_reg);
}
int x64_inst_pointer(scf_native_t* ctx, scf_3ac_code_t* c, int lea_flag)
scf_x64_OpCode_t* lea;
scf_x64_OpCode_t* mov;
+ scf_x64_OpCode_t* shl;
+ scf_x64_OpCode_t* shr;
scf_instruction_t* inst;
int ret = x64_select_reg(&rd, dst->dag_node, c, f, 0);
int is_float = scf_variable_float(vd);
if (is_float) {
if (SCF_VAR_FLOAT == vd->type)
- mov = x64_find_OpCode(SCF_X64_MOVSS, rd->bytes, rd->bytes, SCF_X64_E2G);
+ mov = x64_find_OpCode(SCF_X64_MOVSS, rd->bytes, rd->bytes, SCF_X64_E2G);
else if (SCF_VAR_DOUBLE == vd->type)
- mov = x64_find_OpCode(SCF_X64_MOVSD, rd->bytes, rd->bytes, SCF_X64_E2G);
+ mov = x64_find_OpCode(SCF_X64_MOVSD, rd->bytes, rd->bytes, SCF_X64_E2G);
} else
- mov = x64_find_OpCode(SCF_X64_MOV, rd->bytes, rd->bytes, SCF_X64_E2G);
+ mov = x64_find_OpCode(SCF_X64_MOV, rd->bytes, rd->bytes, SCF_X64_E2G);
}
if (sib.index) {
inst = x64_make_inst_P2G(mov, rd, sib.base, sib.disp);
X64_INST_ADD_CHECK(c->instructions, inst);
}
+
+ if (vm->bit_size > 0) {
+ int imm = (rd->bytes << 3) - vm->bit_size - vm->bit_offset;
+ assert(imm >= 0);
+
+ shl = x64_find_OpCode(SCF_X64_SHL, 1, rd->bytes, SCF_X64_I2E);
+ shr = x64_find_OpCode(SCF_X64_SHR, 1, rd->bytes, SCF_X64_I2E);
+
+ if (imm > 0) {
+ inst = x64_make_inst_I2E(shl, rd, (uint8_t*)&imm, 1);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+ }
+
+ imm += vm->bit_offset;
+ inst = x64_make_inst_I2E(shr, rd, (uint8_t*)&imm, 1);
+ X64_INST_ADD_CHECK(c->instructions, inst);
+ }
+
return 0;
}
-
if (std->src.base)
inst2 = x64_make_inst_E2G((scf_x64_OpCode_t*)inst->OpCode, inst->dst.base, std->src.base);
else {
- OpCode = x64_find_OpCode(inst->OpCode->type, std->src.imm_size, inst->dst.base->bytes, SCF_X64_I2G);
+ OpCode = x64_find_OpCode(inst->OpCode->type, inst->dst.base->bytes, inst->dst.base->bytes, SCF_X64_I2G);
- inst2 = x64_make_inst_I2G(OpCode, inst->dst.base, (uint8_t*)&std->src.imm, std->src.imm_size);
+ if (std->src.imm_size < inst->dst.base->bytes)
+ std->src.imm = scf_zero_extend(std->src.imm, std->src.imm_size);
+
+ inst2 = x64_make_inst_I2G(OpCode, inst->dst.base, (uint8_t*)&std->src.imm, inst->dst.base->bytes);
}
if (!inst2)
return -ENOMEM;
[SCF_OP_3AC_ASSIGN_ARRAY_INDEX ] = _x64_rcg_assign_array_index_handler,
[SCF_OP_3AC_ASSIGN_POINTER ] = _x64_rcg_assign_pointer_handler,
- [SCF_OP_3AC_ADD_ASSIGN_DEREFERENCE] = _x64_rcg_add_assign_dereference_handler,
- [SCF_OP_3AC_ADD_ASSIGN_ARRAY_INDEX] = _x64_rcg_add_assign_array_index_handler,
- [SCF_OP_3AC_ADD_ASSIGN_POINTER ] = _x64_rcg_add_assign_pointer_handler,
-
- [SCF_OP_3AC_SUB_ASSIGN_DEREFERENCE] = _x64_rcg_sub_assign_dereference_handler,
- [SCF_OP_3AC_SUB_ASSIGN_ARRAY_INDEX] = _x64_rcg_sub_assign_array_index_handler,
- [SCF_OP_3AC_SUB_ASSIGN_POINTER ] = _x64_rcg_sub_assign_pointer_handler,
-
- [SCF_OP_3AC_AND_ASSIGN_DEREFERENCE] = _x64_rcg_and_assign_dereference_handler,
- [SCF_OP_3AC_AND_ASSIGN_ARRAY_INDEX] = _x64_rcg_and_assign_array_index_handler,
- [SCF_OP_3AC_AND_ASSIGN_POINTER ] = _x64_rcg_and_assign_pointer_handler,
-
- [SCF_OP_3AC_OR_ASSIGN_DEREFERENCE ] = _x64_rcg_or_assign_dereference_handler,
- [SCF_OP_3AC_OR_ASSIGN_ARRAY_INDEX ] = _x64_rcg_or_assign_array_index_handler,
- [SCF_OP_3AC_OR_ASSIGN_POINTER ] = _x64_rcg_or_assign_pointer_handler,
-
- [SCF_OP_3AC_INC_DEREFERENCE ] = _x64_rcg_inc_dereference_handler,
- [SCF_OP_3AC_INC_ARRAY_INDEX ] = _x64_rcg_inc_array_index_handler,
- [SCF_OP_3AC_INC_POINTER ] = _x64_rcg_inc_pointer_handler,
-
- [SCF_OP_3AC_INC_POST_DEREFERENCE ] = _x64_rcg_inc_post_dereference_handler,
- [SCF_OP_3AC_INC_POST_ARRAY_INDEX ] = _x64_rcg_inc_post_array_index_handler,
- [SCF_OP_3AC_INC_POST_POINTER ] = _x64_rcg_inc_post_pointer_handler,
-
- [SCF_OP_3AC_DEC_DEREFERENCE ] = _x64_rcg_dec_dereference_handler,
- [SCF_OP_3AC_DEC_ARRAY_INDEX ] = _x64_rcg_dec_array_index_handler,
- [SCF_OP_3AC_DEC_POINTER ] = _x64_rcg_dec_pointer_handler,
-
- [SCF_OP_3AC_DEC_POST_DEREFERENCE ] = _x64_rcg_dec_post_dereference_handler,
- [SCF_OP_3AC_DEC_POST_ARRAY_INDEX ] = _x64_rcg_dec_post_array_index_handler,
- [SCF_OP_3AC_DEC_POST_POINTER ] = _x64_rcg_dec_post_pointer_handler,
-
[SCF_OP_3AC_ADDRESS_OF_ARRAY_INDEX] = _x64_rcg_address_of_array_index_handler,
[SCF_OP_3AC_ADDRESS_OF_POINTER ] = _x64_rcg_address_of_pointer_handler,
};
scf_variable_t* v = dn->var;
scf_rela_t* rela = NULL;
scf_x64_OpCode_t* mov;
+ scf_x64_OpCode_t* and;
+ scf_x64_OpCode_t* shl;
scf_instruction_t* inst;
int var_size = x64_variable_size(v);
if (is_float) {
if (SCF_VAR_FLOAT == dn->var->type)
- mov = x64_find_OpCode(SCF_X64_MOVSS, r->bytes, r->bytes, SCF_X64_G2E);
+ mov = x64_find_OpCode(SCF_X64_MOVSS, r->bytes, r->bytes, SCF_X64_G2E);
else if (SCF_VAR_DOUBLE == dn->var->type)
- mov = x64_find_OpCode(SCF_X64_MOVSD, r->bytes, r->bytes, SCF_X64_G2E);
+ mov = x64_find_OpCode(SCF_X64_MOVSD, r->bytes, r->bytes, SCF_X64_G2E);
} else {
- mov = x64_find_OpCode(SCF_X64_MOV, r->bytes, r->bytes, SCF_X64_G2E);
scf_logd("v->size: %d\n", v->size);
+
+ mov = x64_find_OpCode(SCF_X64_MOV, r->bytes, r->bytes, SCF_X64_G2E);
}
inst = x64_make_inst_G2M(&rela, mov, v, NULL, r);
return 0;
scf_x64_OpCode_t* mov;
+ scf_x64_OpCode_t* shr;
+ scf_x64_OpCode_t* and;
scf_instruction_t* inst;
scf_rela_t* rela = NULL;
scf_register_t* base;
scf_register_t* index;
- int32_t scale;
- int32_t disp;
- int32_t size;
+ int32_t scale;
+ int32_t disp;
+ int32_t size;
} x64_sib_t;
static inline int x64_variable_size(scf_variable_t* v)
{
scf_variable_t* v;
+ int bits = 0;
int size = 0;
int i;
int j;
}
size = v->offset + v->size * v->capacity;
- } else
- size = v->offset + v->size;
+ bits = size << 3;
+ } else {
+ if (v->bit_size > 0) {
+ int align = v->size << 3;
+ int used = bits & (align - 1);
+ int rest = align - used;
+
+ if (rest < v->bit_size) {
+ bits += rest;
+ used = 0;
+ rest = align;
+ }
+
+ v->offset = (bits >> 3) & ~(v->size - 1);
+ v->bit_offset = used;
+
+ scf_logd("bits: %d, align: %d, used: %d, rest: %d, v->offset: %d\n", bits, align, used, rest, v->offset);
+
+ bits = (v->offset << 3) + v->bit_offset + v->bit_size;
+ } else
+ bits = (v->offset + v->size) << 3;
- scf_logi("class '%s', member: '%s', member_flag: %d, offset: %d, size: %d, v->dim: %d, v->capacity: %d\n",
- s->name->data, v->w->text->data, v->member_flag, v->offset, v->size, v->nb_dimentions, v->capacity);
+ if (size < v->offset + v->size)
+ size = v->offset + v->size;
+ }
+
+ scf_logi("class '%s', member: '%s', member_flag: %d, offset: %d, size: %d, v->dim: %d, v->capacity: %d, bit offset: %d, bit size: %d\n",
+ s->name->data, v->w->text->data, v->member_flag, v->offset, v->size, v->nb_dimentions, v->capacity, v->bit_offset, v->bit_size);
}
- s->size = size;
+
+ switch (size) {
+ case 1:
+ s->size = size;
+ break;
+ case 2:
+ s->size = (size + 1) & ~0x1;
+ break;
+ case 3:
+ case 4:
+ s->size = (size + 3) & ~0x3;
+ break;
+ default:
+ s->size = (size + 7) & ~0x7;
+ break;
+ };
+
s->node.define_flag = 1;
- scf_logi("class '%s', size: %d\n", s->name->data, s->size);
+ scf_logi("class '%s', s->size: %d, size: %d\n", s->name->data, s->size, size);
return 0;
}
return SCF_DFA_NEXT_WORD;
}
+static int _var_action_colon(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+{
+ scf_parse_t* parse = dfa->priv;
+ dfa_data_t* d = data;
+
+ if (_var_add_var(dfa, d) < 0) {
+ scf_loge("add var error\n");
+ return SCF_DFA_ERROR;
+ }
+
+ if (!d->current_var) {
+ scf_loge("\n");
+ return SCF_DFA_ERROR;
+ }
+
+ return SCF_DFA_NEXT_WORD;
+}
+
+static int _var_action_bits(scf_dfa_t* dfa, scf_vector_t* words, void* data)
+{
+ scf_parse_t* parse = dfa->priv;
+ dfa_data_t* d = data;
+ scf_lex_word_t* w = words->data[words->size - 1];
+
+ if (!d->current_var) {
+ scf_loge("\n");
+ return SCF_DFA_ERROR;
+ }
+
+ if (!d->current_var->member_flag) {
+ scf_loge("bits var '%s' must be a member of struct, file: %s, line: %d\n",
+ d->current_var->w->text->data, d->current_var->w->file->data, d->current_var->w->line);
+ return SCF_DFA_ERROR;
+ }
+
+ d->current_var->bit_size = w->data.u32;
+ return SCF_DFA_NEXT_WORD;
+}
+
static int _var_action_ls(scf_dfa_t* dfa, scf_vector_t* words, void* data)
{
scf_parse_t* parse = dfa->priv;
static int _dfa_init_module_var(scf_dfa_t* dfa)
{
- SCF_DFA_MODULE_NODE(dfa, var, comma, scf_dfa_is_comma, _var_action_comma);
- SCF_DFA_MODULE_NODE(dfa, var, semicolon, scf_dfa_is_semicolon, _var_action_semicolon);
+ SCF_DFA_MODULE_NODE(dfa, var, comma, scf_dfa_is_comma, _var_action_comma);
+ SCF_DFA_MODULE_NODE(dfa, var, semicolon, scf_dfa_is_semicolon, _var_action_semicolon);
+
+ SCF_DFA_MODULE_NODE(dfa, var, ls, scf_dfa_is_ls, _var_action_ls);
+ SCF_DFA_MODULE_NODE(dfa, var, rs, scf_dfa_is_rs, _var_action_rs);
- SCF_DFA_MODULE_NODE(dfa, var, ls, scf_dfa_is_ls, _var_action_ls);
- SCF_DFA_MODULE_NODE(dfa, var, rs, scf_dfa_is_rs, _var_action_rs);
+ SCF_DFA_MODULE_NODE(dfa, var, assign, scf_dfa_is_assign, _var_action_assign);
- SCF_DFA_MODULE_NODE(dfa, var, assign, scf_dfa_is_assign, _var_action_assign);
+ SCF_DFA_MODULE_NODE(dfa, var, colon, scf_dfa_is_colon, _var_action_colon);
+ SCF_DFA_MODULE_NODE(dfa, var, bits, scf_dfa_is_const_integer, _var_action_bits);
return SCF_DFA_OK;
}
SCF_DFA_GET_MODULE_NODE(dfa, var, rs, rs);
SCF_DFA_GET_MODULE_NODE(dfa, var, assign, assign);
+ SCF_DFA_GET_MODULE_NODE(dfa, var, colon, colon);
+ SCF_DFA_GET_MODULE_NODE(dfa, var, bits, bits);
+
SCF_DFA_GET_MODULE_NODE(dfa, type, star, star);
SCF_DFA_GET_MODULE_NODE(dfa, type, identity, identity);
SCF_DFA_GET_MODULE_NODE(dfa, expr, entry, expr);
SCF_DFA_GET_MODULE_NODE(dfa, init_data, entry, init_data);
- SCF_DFA_GET_MODULE_NODE(dfa, init_data, rb, init_data_rb);
+ SCF_DFA_GET_MODULE_NODE(dfa, init_data, rb, init_rb);
scf_dfa_node_add_child(identity, comma);
scf_dfa_node_add_child(rs, comma);
scf_dfa_node_add_child(rs, semicolon);
+ // bits
+ scf_dfa_node_add_child(identity, colon);
+ scf_dfa_node_add_child(colon, bits);
+ scf_dfa_node_add_child(bits, semicolon);
+
// var init
scf_dfa_node_add_child(rs, assign);
scf_dfa_node_add_child(identity, assign);
scf_dfa_node_add_child(expr, semicolon);
// struct or array init
- scf_dfa_node_add_child(assign, init_data);
- scf_dfa_node_add_child(init_data_rb, comma);
- scf_dfa_node_add_child(init_data_rb, semicolon);
+ scf_dfa_node_add_child(assign, init_data);
+ scf_dfa_node_add_child(init_rb, comma);
+ scf_dfa_node_add_child(init_rb, semicolon);
scf_dfa_node_add_child(identity, semicolon);
return 0;
projects / scf.git / commitdiff