narayana
/
ravi
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

issue #169 update MIR from upstream

Browse Source
nometajit
Dibyendu Majumdar 4 years ago
parent 0796d0da0b
commit f5d57a7215
10 changed files with 383 additions and 311 deletions
Show Stats Download Patch File Download Diff File

141
mir/c2mir/c2mir.c
Unescape View File

@ -318,7 +318,9 @@ static void reg_memory_pop (c2m_ctx_t c2m_ctx, size_t mark) {
while (VARR_LENGTH (void_ptr_t, reg_memory) > mark) free (VARR_POP (void_ptr_t, reg_memory));
}
static size_t reg_memory_mark (c2m_ctx_t c2m_ctx) { return VARR_LENGTH (void_ptr_t, reg_memory); }
static size_t MIR_UNUSED reg_memory_mark (c2m_ctx_t c2m_ctx) {
return VARR_LENGTH (void_ptr_t, reg_memory);
}
static void reg_memory_finish (c2m_ctx_t c2m_ctx) {
reg_memory_pop (c2m_ctx, 0);
VARR_DESTROY (void_ptr_t, reg_memory);
@ -876,8 +878,6 @@ static int str_getc (c2m_ctx_t c2m_ctx) {
}
static void add_string_stream (c2m_ctx_t c2m_ctx, const char *pos_fname, const char *str) {
pos_t pos;
add_stream (c2m_ctx, NULL, pos_fname, str_getc);
cs->start = cs->curr = str;
}
@ -1767,7 +1767,7 @@ struct pre_ctx {
VARR (macro_call_t) * macro_call_stack;
VARR (token_t) * pre_expr;
token_t pre_last_token;
pos_t should_be_pre_pos, actual_pre_pos;
pos_t actual_pre_pos;
unsigned long pptokens_num;
};
@ -1786,7 +1786,6 @@ struct pre_ctx {
#define macro_call_stack c2m_ctx->pre_ctx->macro_call_stack
#define pre_expr c2m_ctx->pre_ctx->pre_expr
#define pre_last_token c2m_ctx->pre_ctx->pre_last_token
#define should_be_pre_pos c2m_ctx->pre_ctx->should_be_pre_pos
#define actual_pre_pos c2m_ctx->pre_ctx->actual_pre_pos
#define pptokens_num c2m_ctx->pre_ctx->pptokens_num
@ -2854,12 +2853,22 @@ static node_t pre_cond_expr (c2m_ctx_t c2m_ctx);
/* Expressions: */
static node_t pre_primary_expr (c2m_ctx_t c2m_ctx) {
node_t r;
node_t r, n;
if (pre_match (c2m_ctx, T_NUMBER, NULL, NULL, &r) || pre_match (c2m_ctx, T_CH, NULL, NULL, &r))
return r;
if (pre_match (c2m_ctx, T_CH, NULL, NULL, &r)) return r;
if (pre_match (c2m_ctx, T_NUMBER, NULL, NULL, &n)) {
if (!pre_match (c2m_ctx, '(', NULL, NULL, NULL)) return n;
if (!pre_match (c2m_ctx, ')', NULL, NULL, NULL)) {
for (;;) {
if ((r = pre_cond_expr (c2m_ctx)) == NULL) return NULL;
if (pre_match (c2m_ctx, ')', NULL, NULL, NULL)) break;
if (!pre_match (c2m_ctx, ',', NULL, NULL, NULL)) return NULL;
}
}
return new_pos_node (c2m_ctx, N_IGNORE, n->pos); /* error only during evaluation */
}
if (pre_match (c2m_ctx, '(', NULL, NULL, NULL)) {
if ((r = pre_cond_expr (c2m_ctx)) == NULL) return r;
if ((r = pre_cond_expr (c2m_ctx)) == NULL) return NULL;
if (pre_match (c2m_ctx, ')', NULL, NULL, NULL)) return r;
}
return NULL;
@ -3084,6 +3093,11 @@ static struct val eval (c2m_ctx_t c2m_ctx, node_t tree) {
} while (0)
switch (tree->code) {
case N_IGNORE:
error (c2m_ctx, tree->pos, "wrong preprocessor expression");
res.uns_p = FALSE;
res.u.i_val = 0;
break;
case N_CH:
res.uns_p = !char_is_signed_p () || MIR_CHAR_MAX > MIR_INT_MAX;
if (res.uns_p)
@ -3172,7 +3186,10 @@ static struct val eval (c2m_ctx_t c2m_ctx, node_t tree) {
cond = v1.uns_p ? v1.u.u_val != 0 : v1.u.i_val != 0;
res = eval (c2m_ctx, NL_EL (tree->ops, cond ? 1 : 2));
break;
default: assert (FALSE);
default:
res.uns_p = FALSE;
res.u.i_val = 0;
assert (FALSE);
}
return res;
}
@ -3318,29 +3335,29 @@ static void pre_text_out (c2m_ctx_t c2m_ctx, token_t t) { /* NULL means end of o
fprintf (f, "\n");
return;
}
pre_last_token = t;
if (!t->processed_p) should_be_pre_pos = t->pos;
if (t->code == '\n') return;
if (actual_pre_pos.fname != should_be_pre_pos.fname
|| actual_pre_pos.lno != should_be_pre_pos.lno) {
if (actual_pre_pos.fname == should_be_pre_pos.fname
&& actual_pre_pos.lno < should_be_pre_pos.lno
&& actual_pre_pos.lno + 4 >= should_be_pre_pos.lno) {
for (; actual_pre_pos.lno != should_be_pre_pos.lno; actual_pre_pos.lno++) fprintf (f, "\n");
if (t->code == '\n') {
pre_last_token = t;
return;
}
if (actual_pre_pos.fname != t->pos.fname || actual_pre_pos.lno != t->pos.lno) {
if (actual_pre_pos.fname == t->pos.fname && actual_pre_pos.lno < t->pos.lno
&& actual_pre_pos.lno + 4 >= t->pos.lno) {
for (; actual_pre_pos.lno != t->pos.lno; actual_pre_pos.lno++) fprintf (f, "\n");
} else {
if (pre_last_token != NULL) fprintf (f, "\n");
fprintf (f, "#line %d", should_be_pre_pos.lno);
if (actual_pre_pos.fname != should_be_pre_pos.fname) {
fprintf (f, "#line %d", t->pos.lno);
if (actual_pre_pos.fname != t->pos.fname) {
stringify (t->pos.fname, temp_string);
VARR_PUSH (char, temp_string, '\0');
fprintf (f, " %s", VARR_ADDR (char, temp_string));
}
fprintf (f, "\n");
}
for (i = 0; i < should_be_pre_pos.ln_pos - 1; i++) fprintf (f, " ");
actual_pre_pos = should_be_pre_pos;
for (i = 0; i < t->pos.ln_pos - 1; i++) fprintf (f, " ");
actual_pre_pos = t->pos;
}
fprintf (f, "%s", t->code == ' ' ? " " : t->repr);
pre_last_token = t;
}
static void pre_out (c2m_ctx_t c2m_ctx, token_t t) {
@ -3378,9 +3395,8 @@ static void common_pre_out (c2m_ctx_t c2m_ctx, token_t t) {
static void pre (c2m_ctx_t c2m_ctx, const char *start_source_name) {
pre_last_token = NULL;
actual_pre_pos.fname = NULL;
should_be_pre_pos.fname = start_source_name;
should_be_pre_pos.lno = 0;
should_be_pre_pos.ln_pos = 0;
actual_pre_pos.lno = 0;
actual_pre_pos.ln_pos = 0;
pre_out_token_func = common_pre_out;
pptokens_num = 0;
if (!options->no_prepro_p) {
@ -3819,7 +3835,7 @@ D (asm_spec) {
PTN (T_ID);
if (strcmp (r->u.s.s, "__asm") != 0) PTFAIL (T_ID);
PT ('(');
while (! C (')')) {
while (!C (')')) {
PT (T_STR);
}
PT (')');
@ -3829,6 +3845,7 @@ D (asm_spec) {
static node_t try_attr_spec (c2m_ctx_t c2m_ctx, pos_t pos) {
node_t r;
if (options->pedantic_p) return NULL;
if ((r = TRY (attr_spec)) != err_node) {
if (options->pedantic_p)
error (c2m_ctx, pos, "GCC attributes are not implemented");
@ -3855,6 +3872,7 @@ D (declaration) {
if (curr_scope == top_scope && options->pedantic_p)
warning (c2m_ctx, pos, "extra ; outside of a function");
} else {
try_attr_spec (c2m_ctx, curr_token->pos);
PA (declaration_specs, curr_scope == top_scope ? (node_t) 1 : NULL);
spec = r;
last_pos = spec->pos;
@ -3869,12 +3887,13 @@ D (declaration) {
for (;;) { /* init-declarator */
P (declarator);
decl = r;
last_pos = decl->pos;
last_pos = decl->pos;
assert (decl->code == N_DECL);
if (typedef_p) {
op = NL_HEAD (decl->ops);
tpname_add (op, curr_scope);
}
try_attr_spec (c2m_ctx, last_pos);
if (M ('=')) {
P (initializer);
} else {
@ -3886,7 +3905,6 @@ D (declaration) {
}
}
r = list;
try_attr_spec (c2m_ctx, last_pos);
PT (';');
}
return r;
@ -4848,7 +4866,6 @@ static void parse_init (MIR_context_t ctx) {
#endif
static void add_standard_includes (c2m_ctx_t c2m_ctx) {
FILE *f;
const char *str;
for (int i = 0; i < sizeof (standard_includes) / sizeof (char *); i++) {
@ -5215,7 +5232,7 @@ struct decl {
};
static struct decl_spec *get_param_decl_spec (node_t param) {
node_t declarator;
node_t MIR_UNUSED declarator;
if (param->code == N_TYPE) return param->attr;
declarator = NL_EL (param->ops, 1);
@ -5801,6 +5818,7 @@ static node_t process_tag (c2m_ctx_t c2m_ctx, node_t r, node_t id, node_t decl_l
scope = curr_scope;
while (scope != top_scope && (scope->code == N_STRUCT || scope->code == N_UNION))
scope = ((struct node_scope *) scope->attr)->scope;
sym.def_node = NULL; /* to remove uninitialized warning */
if (decl_list->code != N_IGNORE) {
found_p = symbol_find (c2m_ctx, S_TAG, id, scope, &sym);
} else {
@ -5846,7 +5864,11 @@ static void def_symbol (c2m_ctx_t c2m_ctx, enum symbol_mode mode, node_t id, nod
if (linkage == N_IGNORE) {
if (!decl_spec.typedef_p || !tab_decl_spec.typedef_p
|| !type_eq_p (decl_spec.type, tab_decl_spec.type))
error (c2m_ctx, id->pos, "repeated declaration %s", id->u.s.s);
#ifdef __APPLE__
/* a hack to use our definition instead of macosx for non-GNU compiler */
if (strcmp (id->u.s.s, "__darwin_va_list") != 0)
#endif
error (c2m_ctx, id->pos, "repeated declaration %s", id->u.s.s);
} else if (!compatible_types_p (decl_spec.type, tab_decl_spec.type, FALSE)) {
error (c2m_ctx, id->pos, "incompatible types of %s declarations", id->u.s.s);
}
@ -6373,7 +6395,6 @@ static void check_labels (c2m_ctx_t c2m_ctx, node_t labels, node_t target) {
node_t case_expr2 = l->code == N_CASE ? NL_EL (l->ops, 1) : NULL;
case_t case_attr, tail = DLIST_TAIL (case_t, switch_attr->case_labels);
int ok_p = FALSE, default_p = tail != NULL && tail->case_node->code == N_DEFAULT;
struct expr *expr;
if (case_expr == NULL) {
if (default_p) {
@ -6863,17 +6884,19 @@ static node_t get_compound_literal (node_t n, int *addr_p) {
}
return NULL;
}
static void check_initializer (c2m_ctx_t c2m_ctx, decl_t member_decl, struct type **type_ptr,
node_t initializer, int const_only_p, int top_p) {
struct type *type = *type_ptr;
struct expr *cexpr;
node_t literal, des_list, curr_des, init, str, value, size_node, temp;
mir_llong max_index, size_val;
mir_llong max_index;
mir_llong size_val = 0; /* to remove an uninitialized warning */
size_t mark, len;
symbol_t sym;
struct expr *sexpr;
init_object_t init_object;
int addr_p;
int addr_p = FALSE; /* to remove an uninitialized warning */
literal = get_compound_literal (initializer, &addr_p);
if (literal != NULL && !addr_p && initializer->code != N_STR) {
@ -7052,7 +7075,8 @@ static void create_decl (c2m_ctx_t c2m_ctx, node_t scope, node_t decl_node,
struct decl_spec decl_spec, node_t width, node_t initializer,
int param_p) {
int func_def_p = decl_node->code == N_FUNC_DEF, func_p = FALSE;
node_t id, list_head, declarator;
node_t id = NULL; /* to remove an uninitialized warning */
node_t list_head, declarator;
struct type *type;
decl_t decl = reg_malloc (c2m_ctx, sizeof (struct decl));
@ -7211,7 +7235,8 @@ static void get_int_node (c2m_ctx_t c2m_ctx, node_t *op, struct expr **e, struct
static struct expr *check_assign_op (c2m_ctx_t c2m_ctx, node_t r, node_t op1, node_t op2,
struct expr *e1, struct expr *e2, struct type *t1,
struct type *t2) {
struct expr *e, *te;
struct expr *e = NULL;
struct expr *te;
struct type t, *tt;
switch (r->code) {
@ -7406,7 +7431,7 @@ static struct expr *check_assign_op (c2m_ctx_t c2m_ctx, node_t r, node_t op1, no
}
}
break;
default: assert (FALSE);
default: e = NULL; assert (FALSE);
}
return e;
}
@ -7519,7 +7544,7 @@ static void process_func_decls_for_allocation (c2m_ctx_t c2m_ctx) {
struct type *type;
struct node_scope *ns, *curr_ns;
node_t scope;
mir_size_t start_offset;
mir_size_t start_offset = 0; /* to remove an uninitialized warning */
/* Exclude decls which will be in regs: */
for (i = j = 0; i < VARR_LENGTH (decl_t, func_decls_for_allocation); i++) {
@ -8226,7 +8251,7 @@ static void check (c2m_ctx_t c2m_ctx, node_t r, node_t context) {
void_p = void_type_p (decl_spec->type);
if (!void_p && !scalar_type_p (decl_spec->type)) {
error (c2m_ctx, r->pos, "conversion to non-scalar type requested");
} else if (!scalar_type_p (t2)) {
} else if (!scalar_type_p (t2) && !void_type_p (t2)) {
error (c2m_ctx, r->pos, "conversion of non-scalar value requested");
} else if (t2->mode == TM_PTR && floating_type_p (decl_spec->type)) {
error (c2m_ctx, r->pos, "conversion of a pointer to floating value requested");
@ -8278,7 +8303,7 @@ static void check (c2m_ctx_t c2m_ctx, node_t r, node_t context) {
break;
}
case N_CALL: {
struct func_type *func_type;
struct func_type *func_type = NULL; /* to remove an uninitialized warning */
struct type *ret_type;
node_t list, spec_list, decl, param_list, start_param, param, arg_list, arg;
node_t saved_scope = curr_scope;
@ -9180,7 +9205,7 @@ static MIR_type_t get_int_mir_type (size_t size) {
return size == 1 ? MIR_T_I8 : size == 2 ? MIR_T_I16 : size == 4 ? MIR_T_I32 : MIR_T_I64;
}
static int get_int_mir_type_size (MIR_type_t t) {
static int MIR_UNUSED get_int_mir_type_size (MIR_type_t t) {
return (t == MIR_T_I8 || t == MIR_T_U8
? 1
: t == MIR_T_I16 || t == MIR_T_U16 ? 2 : t == MIR_T_I32 || t == MIR_T_U32 ? 4 : 8);
@ -9929,12 +9954,13 @@ static void collect_init_els (c2m_ctx_t c2m_ctx, decl_t member_decl, struct type
struct type *type = *type_ptr;
struct expr *cexpr;
node_t literal, des_list, curr_des, str, init, value, size_node;
mir_llong size_val;
mir_llong MIR_UNUSED size_val = 0; /* to remove an uninitialized warning */
size_t mark;
symbol_t sym;
struct expr *sexpr;
init_el_t init_el;
int addr_p, found_p, ok_p;
int addr_p = FALSE; /* to remove an uninitialized warning */
int MIR_UNUSED found_p, MIR_UNUSED ok_p;
init_object_t init_object;
literal = get_compound_literal (initializer, &addr_p);
@ -9964,6 +9990,7 @@ check_one_value:
&& type->mode == TM_ARR && char_type_p (type->u.arr_type->el_type)) {
init_el.num = VARR_LENGTH (init_el_t, init_els);
init_el.offset = get_object_path_offset (c2m_ctx);
init_el.member_decl = NULL;
init_el.el_type = type;
init_el.init = str;
VARR_PUSH (init_el_t, init_els, init_el);
@ -10439,10 +10466,10 @@ static op_t gen (MIR_context_t ctx, node_t r, MIR_label_t true_label, MIR_label_
int val_p, op_t *desirable_dest) {
c2m_ctx_t c2m_ctx = *c2m_ctx_loc (ctx);
op_t res, op1, op2, var, val;
MIR_type_t t;
MIR_type_t t = MIR_T_UNDEF; /* to remove an uninitialized warning */
MIR_insn_code_t insn_code;
MIR_type_t mir_type;
struct expr *e;
struct expr *e = NULL; /* to remove an uninitialized warning */
struct type *type;
decl_t decl;
long double ld;
@ -10887,8 +10914,8 @@ static op_t gen (MIR_context_t ctx, node_t r, MIR_label_t true_label, MIR_label_
case N_EXPR_SIZEOF: assert (FALSE); break;
case N_CAST:
assert (!((struct expr *) r->attr)->const_p);
op1 = gen (ctx, NL_EL (r->ops, 1), NULL, NULL, TRUE, NULL);
type = ((struct expr *) r->attr)->type;
op1 = gen (ctx, NL_EL (r->ops, 1), NULL, NULL, !void_type_p (type), NULL);
if (void_type_p (type)) {
res = op1;
res.decl = NULL;
@ -10939,7 +10966,8 @@ static op_t gen (MIR_context_t ctx, node_t r, MIR_label_t true_label, MIR_label_
struct decl_spec *decl_spec;
size_t ops_start;
struct expr *call_expr = r->attr, *func_expr;
struct type *func_type, *type = call_expr->type;
struct type *func_type = NULL; /* to remove an uninitialized warning */
struct type *type = call_expr->type;
MIR_item_t proto_item;
mir_size_t saved_call_arg_area_offset_before_args;
int va_arg_p = call_expr->builtin_call_p && strcmp (func->u.s.s, BUILTIN_VA_ARG) == 0;
@ -11441,7 +11469,6 @@ static op_t gen (MIR_context_t ctx, node_t r, MIR_label_t true_label, MIR_label_
struct type *ret_type = func_type->u.func_type->ret_type;
int scalar_p = scalar_type_p (ret_type);
mir_size_t size = type_size (c2m_ctx, ret_type);
MIR_reg_t ret_addr_reg;
assert (false_label == NULL && true_label == NULL);
emit_label (ctx, r);
@ -11522,7 +11549,7 @@ static int proto_eq (MIR_item_t pi1, MIR_item_t pi2) {
|| VARR_LENGTH (MIR_var_t, p1->args) != VARR_LENGTH (MIR_var_t, p2->args))
return FALSE;
for (uint32_t i = 0; i < p1->nres; i++)
if (p1->res_types[i] != p1->res_types[i]) return FALSE;
if (p1->res_types[i] != p2->res_types[i]) return FALSE;
MIR_var_t *args1 = VARR_ADDR (MIR_var_t, p1->args), *args2 = VARR_ADDR (MIR_var_t, p2->args);
@ -12010,10 +12037,16 @@ static void init_include_dirs (MIR_context_t ctx) {
VARR_PUSH (char_ptr_t, system_headers, str);
}
#if defined(__APPLE__) || defined(__unix__)
VARR_PUSH (char_ptr_t, system_headers, "/usr/include");
#if defined(__linux__) || defined(__x86_64__)
VARR_PUSH (char_ptr_t, system_headers, "/usr/local/include");
#if defined(__APPLE__)
VARR_PUSH (char_ptr_t, system_headers,
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/"
"MacOSX.sdk/usr/include");
#endif
#if defined(__linux__) && defined(__x86_64__)
VARR_PUSH (char_ptr_t, system_headers, "/usr/include/x86_64-linux-gnu");
#endif
VARR_PUSH (char_ptr_t, system_headers, "/usr/include");
#endif
VARR_PUSH (char_ptr_t, system_headers, NULL);
header_dirs = (const char **) VARR_ADDR (char_ptr_t, headers);
@ -12155,7 +12188,6 @@ int c2mir_compile (MIR_context_t ctx, struct c2mir_options *ops, int (*getc_func
node_t r;
unsigned n_error_before;
MIR_module_t m;
const char *base_name;
if (c2m_ctx == NULL) return 0;
if (setjmp (c2m_ctx->env)) {
@ -12199,7 +12231,8 @@ int c2mir_compile (MIR_context_t ctx, struct c2mir_options *ops, int (*getc_func
} else if (output_file != NULL) {
(options->asm_p ? MIR_output_module : MIR_write_module) (ctx, output_file, m);
if (ferror (output_file) || fclose (output_file)) {
fprintf (options->message_file, "C2MIR error in writing file %s\n", base_name);
fprintf (options->message_file, "C2MIR error in writing mir for source file %s\n",
source_name);
n_errors++;
}
}

14
mir/c2mir/x86_64/mirc-x86_64-linux.h
Unescape View File

@ -79,11 +79,23 @@ static char x86_64_mirc[]
"typedef unsigned short char16_t;\n"
"typedef unsigned int char32_t;\n"
"\n"
#if defined(__linux__)
"#define __gnu_linux__ 1\n"
"#define __linux 1\n"
"#define __linux__ 1\n"
"#define linux 1\n"
"#define __unix 1\n"
"#define __unix__ 1\n"
"#define linux 1\n"
#elif defined(__APPLE__)
"#define __APPLE__ 1\n"
"typedef struct {\n"
" unsigned int gp_offset;\n"
" unsigned int fp_offset;\n"
" void *overflow_arg_area;\n"
" void *reg_save_area;\n"
"} __darwin_va_list[1];\n"
#else
#error Uknown OS
#endif
"\n"
"void *alloca (unsigned long);\n";

225
mir/mir-dlist.h
Unescape View File

@ -28,8 +28,15 @@ static inline void dlist_assert_fail (const char* op, const char* var) {
#endif
#ifdef __GNUC__
#define MIR_DLIST_UNUSED __attribute__ ((unused))
#else
#define MIR_DLIST_UNUSED
#endif
#define DLIST(T) DLIST_##T
#define DLIST_OP(T, OP) DLIST_##T##_##OP
#define DLIST_OP_DEF(T, OP) MIR_DLIST_UNUSED DLIST_OP (T, OP)
#define DLIST_LINK(T) DLIST_LINK_##T
#define DLIST_LINK_T(T) \
@ -44,115 +51,115 @@ static inline void dlist_assert_fail (const char* op, const char* var) {
T head, tail; \
} DLIST (T)
#define DEF_DLIST_CODE(T, LINK) \
\
static inline void DLIST_OP (T, init) (DLIST (T) * list) { list->head = list->tail = NULL; } \
\
static inline T DLIST_OP (T, head) (DLIST (T) * list) { return list->head; } \
\
static inline T DLIST_OP (T, tail) (DLIST (T) * list) { return list->tail; } \
\
static inline T DLIST_OP (T, prev) (T elem) { return elem->LINK.prev; } \
static inline T DLIST_OP (T, next) (T elem) { return elem->LINK.next; } \
\
static inline T DLIST_OP (T, el) (DLIST (T) * list, int n) { \
T e; \
\
if (n >= 0) { \
for (e = list->head; e != NULL && n != 0; e = e->LINK.next, n--) \
; \
} else { \
for (e = list->tail; e != NULL && n != -1; e = e->LINK.prev, n++) \
; \
} \
return e; \
} \
\
static inline void DLIST_OP (T, prepend) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "prepend", T); \
if (list->head == NULL) { \
DLIST_ASSERT (list->tail == NULL, "prepend", T); \
list->tail = elem; \
} else { \
DLIST_ASSERT (list->head->LINK.prev == NULL, "prepend", T); \
list->head->LINK.prev = elem; \
} \
elem->LINK.prev = NULL; \
elem->LINK.next = list->head; \
list->head = elem; \
} \
\
static inline void DLIST_OP (T, append) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "append", T); \
if (list->tail == NULL) { \
DLIST_ASSERT (list->head == NULL, "append", T); \
list->head = elem; \
} else { \
DLIST_ASSERT (list->tail->LINK.next == NULL, "append", T); \
list->tail->LINK.next = elem; \
} \
elem->LINK.next = NULL; \
elem->LINK.prev = list->tail; \
list->tail = elem; \
} \
\
static inline void DLIST_OP (T, insert_before) (DLIST (T) * list, T before, T elem) { \
DLIST_ASSERT (list&& before&& elem && list->tail, "insert_before", T); \
if (before->LINK.prev == NULL) { \
DLIST_ASSERT (list->head == before, "insert_before", T); \
before->LINK.prev = elem; \
elem->LINK.next = before; \
elem->LINK.prev = NULL; \
list->head = elem; \
} else { \
DLIST_ASSERT (list->head, "insert_before", T); \
before->LINK.prev->LINK.next = elem; \
elem->LINK.prev = before->LINK.prev; \
before->LINK.prev = elem; \
elem->LINK.next = before; \
} \
} \
\
static inline void DLIST_OP (T, insert_after) (DLIST (T) * list, T after, T elem) { \
DLIST_ASSERT (list&& after&& elem && list->head, "insert_after", T); \
if (after->LINK.next == NULL) { \
DLIST_ASSERT (list->tail == after, "insert_after", T); \
after->LINK.next = elem; \
elem->LINK.prev = after; \
elem->LINK.next = NULL; \
list->tail = elem; \
} else { \
DLIST_ASSERT (list->tail, "insert_after", T); \
after->LINK.next->LINK.prev = elem; \
elem->LINK.next = after->LINK.next; \
after->LINK.next = elem; \
elem->LINK.prev = after; \
} \
} \
\
static inline void DLIST_OP (T, remove) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "remove", T); \
if (elem->LINK.prev != NULL) { \
elem->LINK.prev->LINK.next = elem->LINK.next; \
} else { \
DLIST_ASSERT (list->head == elem, "remove", T); \
list->head = elem->LINK.next; \
} \
if (elem->LINK.next != NULL) { \
elem->LINK.next->LINK.prev = elem->LINK.prev; \
} else { \
DLIST_ASSERT (list->tail == elem, "remove", T); \
list->tail = elem->LINK.prev; \
} \
elem->LINK.prev = elem->LINK.next = NULL; \
} \
\
static inline size_t DLIST_OP (T, length) (DLIST (T) * list) { \
size_t len = 0; \
T curr; \
\
for (curr = list->head; curr != NULL; curr = curr->LINK.next) len++; \
return len; \
#define DEF_DLIST_CODE(T, LINK) \
\
static inline void DLIST_OP_DEF (T, init) (DLIST (T) * list) { list->head = list->tail = NULL; } \
\
static inline T DLIST_OP_DEF (T, head) (DLIST (T) * list) { return list->head; } \
\
static inline T DLIST_OP_DEF (T, tail) (DLIST (T) * list) { return list->tail; } \
\
static inline T DLIST_OP_DEF (T, prev) (T elem) { return elem->LINK.prev; } \
static inline T DLIST_OP_DEF (T, next) (T elem) { return elem->LINK.next; } \
\
static inline T DLIST_OP_DEF (T, el) (DLIST (T) * list, int n) { \
T e; \
\
if (n >= 0) { \
for (e = list->head; e != NULL && n != 0; e = e->LINK.next, n--) \
; \
} else { \
for (e = list->tail; e != NULL && n != -1; e = e->LINK.prev, n++) \
; \
} \
return e; \
} \
\
static inline void DLIST_OP_DEF (T, prepend) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "prepend", T); \
if (list->head == NULL) { \
DLIST_ASSERT (list->tail == NULL, "prepend", T); \
list->tail = elem; \
} else { \
DLIST_ASSERT (list->head->LINK.prev == NULL, "prepend", T); \
list->head->LINK.prev = elem; \
} \
elem->LINK.prev = NULL; \
elem->LINK.next = list->head; \
list->head = elem; \
} \
\
static inline void DLIST_OP_DEF (T, append) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "append", T); \
if (list->tail == NULL) { \
DLIST_ASSERT (list->head == NULL, "append", T); \
list->head = elem; \
} else { \
DLIST_ASSERT (list->tail->LINK.next == NULL, "append", T); \
list->tail->LINK.next = elem; \
} \
elem->LINK.next = NULL; \
elem->LINK.prev = list->tail; \
list->tail = elem; \
} \
\
static inline void DLIST_OP_DEF (T, insert_before) (DLIST (T) * list, T before, T elem) { \
DLIST_ASSERT (list&& before&& elem && list->tail, "insert_before", T); \
if (before->LINK.prev == NULL) { \
DLIST_ASSERT (list->head == before, "insert_before", T); \
before->LINK.prev = elem; \
elem->LINK.next = before; \
elem->LINK.prev = NULL; \
list->head = elem; \
} else { \
DLIST_ASSERT (list->head, "insert_before", T); \
before->LINK.prev->LINK.next = elem; \
elem->LINK.prev = before->LINK.prev; \
before->LINK.prev = elem; \
elem->LINK.next = before; \
} \
} \
\
static inline void DLIST_OP_DEF (T, insert_after) (DLIST (T) * list, T after, T elem) { \
DLIST_ASSERT (list&& after&& elem && list->head, "insert_after", T); \
if (after->LINK.next == NULL) { \
DLIST_ASSERT (list->tail == after, "insert_after", T); \
after->LINK.next = elem; \
elem->LINK.prev = after; \
elem->LINK.next = NULL; \
list->tail = elem; \
} else { \
DLIST_ASSERT (list->tail, "insert_after", T); \
after->LINK.next->LINK.prev = elem; \
elem->LINK.next = after->LINK.next; \
after->LINK.next = elem; \
elem->LINK.prev = after; \
} \
} \
\
static inline void DLIST_OP_DEF (T, remove) (DLIST (T) * list, T elem) { \
DLIST_ASSERT (list&& elem, "remove", T); \
if (elem->LINK.prev != NULL) { \
elem->LINK.prev->LINK.next = elem->LINK.next; \
} else { \
DLIST_ASSERT (list->head == elem, "remove", T); \
list->head = elem->LINK.next; \
} \
if (elem->LINK.next != NULL) { \
elem->LINK.next->LINK.prev = elem->LINK.prev; \
} else { \
DLIST_ASSERT (list->tail == elem, "remove", T); \
list->tail = elem->LINK.prev; \
} \
elem->LINK.prev = elem->LINK.next = NULL; \
} \
\
static inline size_t DLIST_OP_DEF (T, length) (DLIST (T) * list) { \
size_t len = 0; \
T curr; \
\
for (curr = list->head; curr != NULL; curr = curr->LINK.next) len++; \
return len; \
}
#define DEF_DLIST(T, LINK) \

4
mir/mir-gen-x86_64.c
Unescape View File

@ -318,6 +318,7 @@ static void get_builtin (MIR_context_t ctx, MIR_insn_code_t code, MIR_item_t *pr
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
MIR_type_t res_type;
*func_import_item = *proto_item = NULL; /* to remove uninitialized warning */
switch (code) {
case MIR_UI2F:
res_type = MIR_T_F;
@ -1484,6 +1485,7 @@ static int setup_imm_addr (struct gen_ctx *gen_ctx, uint64_t v, int *mod, int *r
n = add_to_const_pool (gen_ctx, v);
setup_rip_rel_addr (0, mod, rm, disp32);
cr.pc = 0;
cr.next_insn_disp = 0;
cr.const_num = n;
VARR_PUSH (const_ref_t, const_refs, cr);
return VARR_LENGTH (const_ref_t, const_refs) - 1;
@ -1507,7 +1509,7 @@ static void out_insn (MIR_context_t ctx, MIR_insn_t insn, const char *replacemen
int prefix = -1, disp8 = -1, imm8 = -1, lb = -1;
int64_t disp32 = -1, imm32 = -1;
int imm64_p = FALSE;
uint64_t imm64, v;
uint64_t imm64 = 0, v;
MIR_op_t op;
int const_ref_num = -1, label_ref_num = -1, switch_table_addr_p = FALSE;

34
mir/mir-gen.c
Unescape View File

@ -625,7 +625,7 @@ static void process_loop (MIR_context_t ctx, bb_t entry_bb) {
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
edge_t e;
loop_node_t loop_node, new_loop_node, queue_node;
bb_t loop_bb, queue_bb;
bb_t queue_bb;
VARR_TRUNC (loop_node_t, loop_nodes, 0);
VARR_TRUNC (loop_node_t, queue_nodes, 0);
@ -1941,7 +1941,7 @@ static enum ccp_val_kind get_2isops (MIR_insn_t insn, int32_t *p, int out_p) {
return CCP_CONST;
}
static enum ccp_val_kind get_2usops (MIR_insn_t insn, uint32_t *p, int out_p) {
static enum ccp_val_kind MIR_UNUSED get_2usops (MIR_insn_t insn, uint32_t *p, int out_p) {
const_t val;
enum ccp_val_kind res;
@ -2453,8 +2453,8 @@ static void ccp_process_active_edge (MIR_context_t ctx, edge_t e) {
}
static void ccp_make_insn_update (MIR_context_t ctx, MIR_insn_t insn) {
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
int i, def_p;
struct gen_ctx *gen_ctx MIR_UNUSED = *gen_ctx_loc (ctx);
int i, def_p MIR_UNUSED;
MIR_op_t op;
var_occ_t var_occ;
@ -2480,6 +2480,7 @@ static void ccp_make_insn_update (MIR_context_t ctx, MIR_insn_t insn) {
#endif
} else {
def_p = FALSE;
var_occ = NULL; /* to remove an initilized warning */
for (i = 0; get_ccp_res_op (ctx, insn, i, &op); i++)
if (var_op_p (op)) {
def_p = TRUE;
@ -2504,7 +2505,7 @@ static void ccp_make_insn_update (MIR_context_t ctx, MIR_insn_t insn) {
}
static void ccp_process_insn (MIR_context_t ctx, bb_insn_t bb_insn) {
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
struct gen_ctx *gen_ctx MIR_UNUSED = *gen_ctx_loc (ctx);
int res;
enum ccp_val_kind ccp_res;
edge_t e;
@ -2928,6 +2929,7 @@ static void initiate_live_info (MIR_context_t ctx, int moves_p) {
nregs = get_nregs (ctx);
for (n = 0; n < nregs; n++) {
ri.freq = ri.thread_freq = ri.calls_num = 0;
ri.live_length = 0;
ri.thread_first = n;
ri.thread_next = MIR_MAX_REG_NUM;
DLIST_INIT (dst_mv_t, ri.dst_moves);
@ -3303,7 +3305,7 @@ struct ra_ctx {
static void process_move_to_form_thread (MIR_context_t ctx, mv_t mv) {
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
MIR_op_t op1 = mv->bb_insn->insn->ops[0], op2 = mv->bb_insn->insn->ops[1];
MIR_reg_t i, breg1, breg2, breg1_first, breg2_first, last;
MIR_reg_t breg1, breg2, breg1_first, breg2_first, last;
if (op1.mode != MIR_OP_REG || op2.mode != MIR_OP_REG) return;
breg1 = reg2breg (gen_ctx, op1.u.reg);
@ -3381,6 +3383,7 @@ static void assign (MIR_context_t ctx) {
bitmap_t *point_used_locs_addr;
breg_info_t breg_info;
func_stack_slots_num = 0;
if (nregs == 0) return;
curr_breg_infos = VARR_ADDR (reg_info_t, curr_cfg->breg_info);
VARR_TRUNC (MIR_reg_t, breg_renumber, 0);
@ -3420,7 +3423,6 @@ static void assign (MIR_context_t ctx) {
for (lr = VARR_GET (live_range_t, var_live_ranges, i); lr != NULL; lr = lr->next)
for (j = lr->start; j <= lr->finish; j++) bitmap_set_bit_p (point_used_locs_addr[j], i);
}
func_stack_slots_num = 0;
bitmap_clear (func_assigned_hard_regs);
for (i = 0; i < nregs; i++) { /* hard reg and stack slot assignment */
breg = VARR_GET (breg_info_t, sorted_bregs, i).breg;
@ -3558,7 +3560,11 @@ static void rewrite (MIR_context_t ctx) {
MIR_insn_t insn;
bb_insn_t bb_insn, next_bb_insn;
size_t nops, i;
MIR_op_t *op, in_op, out_op, mem_op;
MIR_op_t *op, mem_op;
#if MIR_GEN_DEBUG
MIR_op_t in_op = MIR_new_int_op (ctx, 0),
out_op = MIR_new_int_op (ctx, 0); /* To remove unitilized warning */
#endif
MIR_mem_t mem;
MIR_op_mode_t data_mode;
MIR_reg_t hard_reg;
@ -3574,10 +3580,12 @@ static void rewrite (MIR_context_t ctx) {
for (i = 0; i < nops; i++) {
op = &insn->ops[i];
data_mode = MIR_insn_op_mode (ctx, insn, i, &out_p);
#if MIR_GEN_DEBUG
if (out_p)
out_op = *op; /* we don't care about multiple call outputs here */
else
in_op = *op;
#endif
switch (op->mode) {
case MIR_OP_REG:
hard_reg
@ -4025,6 +4033,7 @@ static int combine_substitute (MIR_context_t ctx, bb_insn_t bb_insn) {
code = insn->code;
if (i >= nops && (code == MIR_MUL || code == MIR_MULS || code == MIR_UDIV || code == MIR_UDIVS)
&& insn->ops[2].mode == MIR_OP_INT && (sh = int_log2 (insn->ops[2].u.i)) >= 0) {
new_code = code; /* to remove an initialized warning */
switch (code) {
case MIR_MUL: new_code = MIR_LSH; break;
case MIR_MULS: new_code = MIR_LSHS; break;
@ -4166,13 +4175,12 @@ static void setup_hreg_ref (MIR_context_t ctx, MIR_reg_t hr, MIR_insn_t insn, si
static void combine (MIR_context_t ctx) {
struct gen_ctx *gen_ctx = *gen_ctx_loc (ctx);
MIR_insn_code_t code, new_code;
MIR_insn_t insn, new_insn, def_insn;
MIR_insn_t insn, new_insn;
bb_insn_t bb_insn;
size_t iter, nops, i, curr_insn_num;
MIR_op_t temp_op, *op_ref;
MIR_reg_t hr, early_clobbered_hard_reg1, early_clobbered_hard_reg2;
MIR_reg_t early_clobbered_hard_reg1, early_clobbered_hard_reg2;
int out_p, change_p, block_change_p;
int64_t p;
#if MIR_GEN_DEBUG
size_t insns_num = 0, deleted_insns_num = 0;
#endif
@ -4438,7 +4446,7 @@ void *MIR_gen (MIR_context_t ctx, MIR_item_t func_item) {
uint8_t *code;
size_t code_len;
#if MIR_GEN_DEBUG
double start_time;
double start_time = 0.0;
#endif
gen_assert (func_item->item_type == MIR_func_item && func_item->data == NULL);
@ -4575,7 +4583,7 @@ void *MIR_gen (MIR_context_t ctx, MIR_item_t func_item) {
= _MIR_publish_code (ctx, code, code_len);
target_rebase (ctx, func_item->u.func->machine_code);
#if MIR_GEN_CALL_TRACE
func_item->u.func->call_addr = _MIR_get_wrapper (ctx, called_func, print_and_execute_wrapper);
func_item->u.func->call_addr = _MIR_get_wrapper (ctx, func_item, print_and_execute_wrapper);
#endif
#if MIR_GEN_DEBUG
if (debug_file != NULL) {

22
mir/mir-htab.h
Unescape View File

@ -28,8 +28,10 @@ static inline void mir_htab_assert_fail (const char *op, const char *var) {
#endif
#ifdef __GNUC__
#define MIR_HTAB_UNUSED __attribute__ ((unused))
#define MIR_HTAB_NO_RETURN __attribute__ ((noreturn))
#else
#define MIR_HTAB_UNUSED
#define MIR_HTAB_NO_RETURN
#endif
@ -56,6 +58,7 @@ enum htab_action { HTAB_FIND, HTAB_INSERT, HTAB_REPLACE, HTAB_DELETE };
#define HTAB(T) HTAB_##T
#define HTAB_OP(T, OP) HTAB_##T##_##OP
#define HTAB_OP_DEF(T, OP) MIR_HTAB_UNUSED HTAB_OP (T, OP)
DEF_VARR (htab_ind_t)
@ -79,10 +82,10 @@ DEF_VARR (htab_ind_t)
#define DEF_HTAB(T) \
HTAB_T (T) \
\
static inline void HTAB_OP (T, create) (HTAB (T) * *htab, htab_size_t min_size, \
htab_hash_t (*hash_func) (T el), \
int (*eq_func) (T el1, T el2), \
void (*free_func) (T el)) { \
static inline void HTAB_OP_DEF (T, create) (HTAB (T) * *htab, htab_size_t min_size, \
htab_hash_t (*hash_func) (T el), \
int (*eq_func) (T el1, T el2), \
void (*free_func) (T el)) { \
HTAB (T) * ht; \
htab_size_t i, size; \
\
@ -101,7 +104,7 @@ DEF_VARR (htab_ind_t)
*htab = ht; \
} \
\
static inline void HTAB_OP (T, clear) (HTAB (T) * htab) { \
static inline void HTAB_OP_DEF (T, clear) (HTAB (T) * htab) { \
htab_ind_t *addr; \
htab_size_t i, size; \
HTAB_EL (T) * els_addr; \
@ -119,7 +122,7 @@ DEF_VARR (htab_ind_t)
for (i = 0; i < size; i++) addr[i] = HTAB_EMPTY_IND; \
} \
\
static inline void HTAB_OP (T, destroy) (HTAB (T) * *htab) { \
static inline void HTAB_OP_DEF (T, destroy) (HTAB (T) * *htab) { \
HTAB_ASSERT (*htab != NULL, "destroy", T); \
if ((*htab)->free_func != NULL) HTAB_OP (T, clear) (*htab); \
VARR_DESTROY (HTAB_EL (T), (*htab)->els); \
@ -128,7 +131,8 @@ DEF_VARR (htab_ind_t)
*htab = NULL; \
} \
\
static inline int HTAB_OP (T, do) (HTAB (T) * htab, T el, enum htab_action action, T * res) { \
static inline int HTAB_OP_DEF (T, do) (HTAB (T) * htab, T el, enum htab_action action, \
T * res) { \
htab_ind_t ind, el_ind, *entry, *first_deleted_entry = NULL; \
htab_hash_t hash, peterb; \
htab_size_t els_size, size, mask, start, bound, i; \
@ -200,11 +204,11 @@ DEF_VARR (htab_ind_t)
} \
} \
\
static inline htab_size_t HTAB_OP (T, els_num) (HTAB (T) * htab) { \
static inline htab_size_t HTAB_OP_DEF (T, els_num) (HTAB (T) * htab) { \
HTAB_ASSERT (htab != NULL, "els_num", T); \
return htab->els_num; \
} \
static inline htab_size_t HTAB_OP (T, collisions) (HTAB (T) * htab) { \
static inline htab_size_t HTAB_OP_DEF (T, collisions) (HTAB (T) * htab) { \
HTAB_ASSERT (htab != NULL, "collisions", T); \
return htab->collisions; \
}

12
mir/mir-interp.c
Unescape View File

@ -379,6 +379,7 @@ static void generate_icode (MIR_context_t ctx, MIR_item_t func_item) {
} else if (i == 1 && imm_call_p) {
mir_assert (ops[i].u.ref->item_type == MIR_import_item
|| ops[i].u.ref->item_type == MIR_export_item
|| ops[i].u.ref->item_type == MIR_forward_item
|| ops[i].u.ref->item_type == MIR_func_item);
v.a = ops[i].u.ref->addr;
} else if (code == MIR_VA_ARG && i == 2) { /* type */
@ -755,10 +756,10 @@ static void start_insn_trace (MIR_context_t ctx, const char *name, func_desc_t f
}
fprintf (stderr, "\t#");
MIR_output_insn (ctx, stderr, insn, func_desc->func_item->u.func, FALSE);
fprintf (stderr, "");
}
static void finish_insn_trace (MIR_context_t ctx, MIR_insn_code_t code, code_t ops, MIR_val_t *bp) {
static void finish_insn_trace (MIR_context_t ctx, MIR_full_insn_code_t code, code_t ops,
MIR_val_t *bp) {
int out_p;
MIR_op_mode_t op_mode = MIR_OP_UNDEF;
@ -790,7 +791,7 @@ static void finish_insn_trace (MIR_context_t ctx, MIR_insn_code_t code, code_t o
case IC_STLD: break;
case IC_IMM_CALL: break;
default:
op_mode = _MIR_insn_code_op_mode (ctx, code, 0, &out_p);
op_mode = _MIR_insn_code_op_mode (ctx, (MIR_insn_code_t) code, 0, &out_p);
if (op_mode == MIR_OP_BOUND || !out_p) op_mode = MIR_OP_UNDEF;
break;
}
@ -805,6 +806,7 @@ static void finish_insn_trace (MIR_context_t ctx, MIR_insn_code_t code, code_t o
case MIR_OP_LDOUBLE:
fprintf (stderr, "\t# res = %.*Le", LDBL_DECIMAL_DIG, bp[ops[0].i].ld);
break;
default: assert (FALSE);
}
fprintf (stderr, "\n");
}
@ -845,7 +847,7 @@ static void OPTIMIZE eval (MIR_context_t ctx, func_desc_t func_desc, MIR_val_t *
MIR_full_insn_code_t trace_insn_code;
#define START_INSN(v, nops) \
do { \
trace_insn_code = v; \
trace_insn_code = (MIR_full_insn_code_t) v; \
start_insn_trace (ctx, #v, func_desc, pc, nops); \
ops = pc + 2; /* skip original insn too */ \
pc += nops + 2; \
@ -931,7 +933,7 @@ static void OPTIMIZE eval (MIR_context_t ctx, func_desc_t func_desc, MIR_val_t *
goto * pc->a;
#else
for (;;) {
MIR_insn_code_t insn_code = pc->ic;
int insn_code = pc->ic;
switch (insn_code) {
#endif

9
mir/mir-reduce.h
Unescape View File

@ -197,8 +197,8 @@ static inline uint32_t _reduce_dict_find_longest (struct reduce_data *data, uint
uint32_t *dict_pos) {
uint32_t len, best_len, len_bound;
uint64_t hash;
uint32_t off, best_off, ref_size, best_ref_size;
uint32_t curr, prev, next;
uint32_t off, ref_size, best_ref_size;
uint32_t curr, next;
const uint8_t *s1, *s2;
struct _reduce_el *el, *best_el = NULL;
struct _reduce_encode_data *encode_data = &data->u.encode;
@ -209,8 +209,7 @@ static inline uint32_t _reduce_dict_find_longest (struct reduce_data *data, uint
compression speed by 10%. */
hash
= mir_hash_strict (&data->buf[pos], _REDUCE_START_LEN, _REDUCE_HASH_SEED) % _REDUCE_TABLE_SIZE;
for (curr = encode_data->table[hash].head, prev = UINT32_MAX; curr != UINT32_MAX;
prev = curr, curr = next) {
for (curr = encode_data->table[hash].head; curr != UINT32_MAX; curr = next) {
next = encode_data->table[curr].next;
el = &encode_data->table[curr];
len_bound = _reduce_min (data->buf_bound - pos, pos - el->pos);
@ -236,7 +235,6 @@ static inline uint32_t _reduce_dict_find_longest (struct reduce_data *data, uint
best_ref_size = _reduce_ref_size (len, off);
continue;
}
best_off = data->curr_num - best_el->num;
ref_size = _reduce_ref_size (len, off);
if (best_len + ref_size < len + best_ref_size) {
best_len = len;
@ -251,7 +249,6 @@ static inline uint32_t _reduce_dict_find_longest (struct reduce_data *data, uint
static inline void _reduce_dict_add (struct reduce_data *data, uint32_t pos) {
uint64_t hash;
struct _reduce_el *el;
uint32_t prev, curr, num = data->curr_num++;
struct _reduce_encode_data *encode_data = &data->u.encode;

189
mir/mir-varr.h
Unescape View File

@ -27,8 +27,10 @@ static inline void mir_var_assert_fail (const char *op, const char *var) {
#endif
#ifdef __GNUC__
#define MIR_VARR_UNUSED __attribute__ ((unused))
#define MIR_VARR_NO_RETURN __attribute__ ((noreturn))
#else
#define MIR_VARR_UNUSED
#define MIR_VARR_NO_RETURN
#endif
@ -47,6 +49,7 @@ static inline void MIR_VARR_NO_RETURN mir_varr_error (const char *message) {
#define VARR_CONCAT3(A, B, C) A##B##C
#define VARR(T) VARR_CONCAT2 (VARR_, T)
#define VARR_OP(T, OP) VARR_CONCAT3 (VARR_, T, OP)
#define VARR_OP_DEF(T, OP) MIR_VARR_UNUSED VARR_OP (T, OP)
#define VARR_T(T) \
typedef struct VARR (T) { \
@ -58,99 +61,99 @@ static inline void MIR_VARR_NO_RETURN mir_varr_error (const char *message) {
#define VARR_DEFAULT_SIZE 64
/* Vector of pointer to object. */
#define DEF_VARR(T) \
VARR_T (T); \
\
static inline void VARR_OP (T, create) (VARR (T) * *varr, size_t size) { \
VARR (T) * va; \
if (size == 0) size = VARR_DEFAULT_SIZE; \
*varr = va = (VARR (T) *) malloc (sizeof (VARR (T))); \
if (va == NULL) mir_varr_error ("varr: no memory"); \
va->els_num = 0; \
va->size = size; \
va->varr = (T *) malloc (size * sizeof (T)); \
} \
\
static inline void VARR_OP (T, destroy) (VARR (T) * *varr) { \
VARR (T) *va = *varr; \
VARR_ASSERT (va && va->varr, "destroy", T); \
free (va->varr); \
free (va); \
*varr = NULL; \
} \
\
static inline size_t VARR_OP (T, length) (const VARR (T) * varr) { \
VARR_ASSERT (varr, "length", T); \
return varr->els_num; \
} \
\
static inline T *VARR_OP (T, addr) (const VARR (T) * varr) { \
VARR_ASSERT (varr, "addr", T); \
return &varr->varr[0]; \
} \
\
static inline T VARR_OP (T, last) (const VARR (T) * varr) { \
VARR_ASSERT (varr && varr->varr && varr->els_num, "last", T); \
return varr->varr[varr->els_num - 1]; \
} \
\
static inline T VARR_OP (T, get) (const VARR (T) * varr, unsigned ix) { \
VARR_ASSERT (varr && varr->varr && ix < varr->els_num, "get", T); \
return varr->varr[ix]; \
} \
\
static inline T VARR_OP (T, set) (const VARR (T) * varr, unsigned ix, T obj) { \
T old_obj; \
VARR_ASSERT (varr && varr->varr && ix < varr->els_num, "set", T); \
old_obj = varr->varr[ix]; \
varr->varr[ix] = obj; \
return old_obj; \
} \
\
static inline void VARR_OP (T, trunc) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr && varr->els_num >= size, "trunc", T); \
varr->els_num = size; \
} \
\
static inline int VARR_OP (T, expand) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr, "expand", T); \
if (varr->size < size) { \
size += size / 2; \
varr->varr = (T *) realloc (varr->varr, sizeof (T) * size); \
varr->size = size; \
return 1; \
} \
return 0; \
} \
\
static inline void VARR_OP (T, tailor) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr, "tailor", T); \
if (varr->size != size) varr->varr = (T *) realloc (varr->varr, sizeof (T) * size); \
varr->els_num = varr->size = size; \
} \
\
static inline void VARR_OP (T, push) (VARR (T) * varr, T obj) { \
T *slot; \
VARR_OP (T, expand) (varr, varr->els_num + 1); \
slot = &varr->varr[varr->els_num++]; \
*slot = obj; \
} \
\
static inline void VARR_OP (T, push_arr) (VARR (T) * varr, const T *objs, size_t len) { \
size_t i; \
T *slot; \
VARR_OP (T, expand) (varr, varr->els_num + len); \
for (i = 0; i < len; i++) { \
slot = &varr->varr[varr->els_num++]; \
*slot = objs[i]; \
} \
} \
\
static inline T VARR_OP (T, pop) (VARR (T) * varr) { \
T obj; \
VARR_ASSERT (varr && varr->varr && varr->els_num, "pop", T); \
obj = varr->varr[--varr->els_num]; \
return obj; \
#define DEF_VARR(T) \
VARR_T (T); \
\
static inline void VARR_OP_DEF (T, create) (VARR (T) * *varr, size_t size) { \
VARR (T) * va; \
if (size == 0) size = VARR_DEFAULT_SIZE; \
*varr = va = (VARR (T) *) malloc (sizeof (VARR (T))); \
if (va == NULL) mir_varr_error ("varr: no memory"); \
va->els_num = 0; \
va->size = size; \
va->varr = (T *) malloc (size * sizeof (T)); \
} \
\
static inline void VARR_OP_DEF (T, destroy) (VARR (T) * *varr) { \
VARR (T) *va = *varr; \
VARR_ASSERT (va && va->varr, "destroy", T); \
free (va->varr); \
free (va); \
*varr = NULL; \
} \
\
static inline size_t VARR_OP_DEF (T, length) (const VARR (T) * varr) { \
VARR_ASSERT (varr, "length", T); \
return varr->els_num; \
} \
\
static inline T *VARR_OP_DEF (T, addr) (const VARR (T) * varr) { \
VARR_ASSERT (varr, "addr", T); \
return &varr->varr[0]; \
} \
\
static inline T VARR_OP_DEF (T, last) (const VARR (T) * varr) { \
VARR_ASSERT (varr && varr->varr && varr->els_num, "last", T); \
return varr->varr[varr->els_num - 1]; \
} \
\
static inline T VARR_OP_DEF (T, get) (const VARR (T) * varr, unsigned ix) { \
VARR_ASSERT (varr && varr->varr && ix < varr->els_num, "get", T); \
return varr->varr[ix]; \
} \
\
static inline T VARR_OP_DEF (T, set) (const VARR (T) * varr, unsigned ix, T obj) { \
T old_obj; \
VARR_ASSERT (varr && varr->varr && ix < varr->els_num, "set", T); \
old_obj = varr->varr[ix]; \
varr->varr[ix] = obj; \
return old_obj; \
} \
\
static inline void VARR_OP_DEF (T, trunc) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr && varr->els_num >= size, "trunc", T); \
varr->els_num = size; \
} \
\
static inline int VARR_OP_DEF (T, expand) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr, "expand", T); \
if (varr->size < size) { \
size += size / 2; \
varr->varr = (T *) realloc (varr->varr, sizeof (T) * size); \
varr->size = size; \
return 1; \
} \
return 0; \
} \
\
static inline void VARR_OP_DEF (T, tailor) (VARR (T) * varr, size_t size) { \
VARR_ASSERT (varr && varr->varr, "tailor", T); \
if (varr->size != size) varr->varr = (T *) realloc (varr->varr, sizeof (T) * size); \
varr->els_num = varr->size = size; \
} \
\
static inline void VARR_OP_DEF (T, push) (VARR (T) * varr, T obj) { \
T *slot; \
VARR_OP (T, expand) (varr, varr->els_num + 1); \
slot = &varr->varr[varr->els_num++]; \
*slot = obj; \
} \
\
static inline void VARR_OP_DEF (T, push_arr) (VARR (T) * varr, const T *objs, size_t len) { \
size_t i; \
T *slot; \
VARR_OP (T, expand) (varr, varr->els_num + len); \
for (i = 0; i < len; i++) { \
slot = &varr->varr[varr->els_num++]; \
*slot = objs[i]; \
} \
} \
\
static inline T VARR_OP_DEF (T, pop) (VARR (T) * varr) { \
T obj; \
VARR_ASSERT (varr && varr->varr && varr->els_num, "pop", T); \
obj = varr->varr[--varr->els_num]; \
return obj; \
}
#define VARR_CREATE(T, V, L) (VARR_OP (T, create) (&(V), L))

44
mir/mir.c
Unescape View File

@ -105,7 +105,7 @@ static void MIR_NO_RETURN default_error (enum MIR_error_type error_type, const c
exit (1);
}
static void MIR_NO_RETURN util_error (MIR_context_t ctx, const char *message) {
static void MIR_NO_RETURN MIR_UNUSED util_error (MIR_context_t ctx, const char *message) {
(*error_func) (MIR_alloc_error, message);
}
@ -472,21 +472,6 @@ static void reg_init (MIR_context_t ctx) {
HTAB_CREATE (size_ctx_t, reg2rdn_tab, 300, reg2rdn_hash, reg2rdn_eq);
}
static int func_reg_p (MIR_context_t ctx, MIR_func_t func, const char *name) {
size_ctx_t sc, tab_sc;
reg_desc_t rd;
int res;
rd.name_num = string_store (ctx, &strings, &string_tab, (MIR_str_t){strlen (name) + 1, name}).num;
rd.func = func;
sc.rdn = VARR_LENGTH (reg_desc_t, reg_descs);
sc.ctx = ctx;
VARR_PUSH (reg_desc_t, reg_descs, rd);
res = HTAB_DO (size_ctx_t, namenum2rdn_tab, sc, HTAB_FIND, tab_sc);
VARR_POP (reg_desc_t, reg_descs);
return res;
}
static MIR_reg_t create_func_reg (MIR_context_t ctx, MIR_func_t func, const char *name,
MIR_reg_t reg, MIR_type_t type, int any_p) {
reg_desc_t rd;
@ -1589,6 +1574,7 @@ MIR_op_mode_t MIR_insn_op_mode (MIR_context_t ctx, MIR_insn_t insn, size_t nop,
size_t nargs, nops = MIR_insn_nops (ctx, insn);
unsigned mode;
*out_p = FALSE; /* to remove unitialized warning */
if (nop >= nops) return MIR_OP_BOUND;
mir_assert (out_p != NULL);
if (code == MIR_RET || code == MIR_SWITCH) {
@ -2592,7 +2578,7 @@ static void make_one_ret (MIR_context_t ctx, MIR_item_t func_item) {
MIR_op_t reg_op, ret_reg_op;
MIR_func_t func = func_item->u.func;
MIR_type_t *res_types = func->res_types;
MIR_insn_t ret_label, insn, first_ret_insn;
MIR_insn_t ret_label, insn, first_ret_insn = NULL;
VARR (MIR_op_t) * ret_ops;
int one_last_ret_p;
@ -3470,7 +3456,7 @@ static size_t write_ldouble (MIR_context_t ctx, writer_func_t writer, long doubl
static size_t write_str_tag (MIR_context_t ctx, writer_func_t writer, MIR_str_t str,
bin_tag_t start_tag) {
size_t nb, len;
size_t nb;
int ok_p;
string_t string;
@ -4112,6 +4098,7 @@ static int func_proto_read (MIR_context_t ctx, MIR_module_t module, uint64_t *nr
return vararg_p;
}
#ifndef MIR_NO_BIN_COMPRESSION
static size_t reduce_reader (void *start, size_t len, void *data) {
MIR_context_t ctx = data;
size_t i;
@ -4120,6 +4107,7 @@ static size_t reduce_reader (void *start, size_t len, void *data) {
for (i = 0; i < len && (c = io_reader (ctx)) != EOF; i++) ((char *) start)[i] = c;
return i;
}
#endif
void MIR_read_with_func (MIR_context_t ctx, int (*const reader) (MIR_context_t)) {
int version;
@ -4503,8 +4491,9 @@ struct scan_ctx {
#define label_names ctx->scan_ctx->label_names
#define label_desc_tab ctx->scan_ctx->label_desc_tab
static void MIR_NO_RETURN process_error (MIR_context_t ctx, enum MIR_error_type error_type,
const char *message) {
static void MIR_NO_RETURN MIR_UNUSED process_error (MIR_context_t ctx,
enum MIR_error_type error_type,
const char *message) {
(*error_func) (error_type, "ln %lu: %s", (unsigned long) curr_lno, message);
longjmp (error_jmp_buf, TRUE);
}
@ -4779,6 +4768,21 @@ MIR_type_t MIR_str2type (MIR_context_t ctx, const char *type_name) {
return MIR_T_BOUND;
}
static int func_reg_p (MIR_context_t ctx, MIR_func_t func, const char *name) {
size_ctx_t sc, tab_sc;
reg_desc_t rd;
int res;
rd.name_num = string_store (ctx, &strings, &string_tab, (MIR_str_t){strlen (name) + 1, name}).num;
rd.func = func;
sc.rdn = VARR_LENGTH (reg_desc_t, reg_descs);
sc.ctx = ctx;
VARR_PUSH (reg_desc_t, reg_descs, rd);
res = HTAB_DO (size_ctx_t, namenum2rdn_tab, sc, HTAB_FIND, tab_sc);
VARR_POP (reg_desc_t, reg_descs);
return res;
}
static void read_func_proto (MIR_context_t ctx, size_t nops, MIR_op_t *ops) {
MIR_var_t var;
size_t i;

Write Preview
Loading…
Cancel
Save