Commit 2672e202 authored by Matthias Braun's avatar Matthias Braun
Browse files

coding style cleanup, use C99

parent 9697d318
......@@ -31,16 +31,11 @@
*/
static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
{
int i, p;
ir_node *succ;
/* We must visit a node once to avoid endless recursion.*/
mark_irn_visited(arg);
for (i = get_irn_n_outs(arg) - 1; i >= 0; --i) {
succ = get_irn_out(arg, i);
/* We was here.*/
for (int i = get_irn_n_outs(arg); i-- > 0; ) {
ir_node *succ = get_irn_out(arg, i);
if (irn_visited(succ))
continue;
......@@ -68,7 +63,7 @@ static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
if (is_SymConst_addr_ent(ptr)) {
meth_ent = get_SymConst_entity(ptr);
for (p = get_Call_n_params(succ) - 1; p >= 0; --p) {
for (int p = get_Call_n_params(succ); p-- > 0; ) {
if (get_Call_param(succ, p) == arg) {
/* an arg can be used more than once ! */
bits |= get_method_param_access(meth_ent, p);
......@@ -76,11 +71,10 @@ static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
}
} else if (is_Sel(ptr) && get_irp_callee_info_state() == irg_callee_info_consistent) {
/* is be a polymorphic call but callee information is available */
int n_params = get_Call_n_params(succ);
int c;
size_t n_params = get_Call_n_params(succ);
/* simply look into ALL possible callees */
for (c = get_Call_n_callees(succ) - 1; c >= 0; --c) {
for (int c = get_Call_n_callees(succ); c-- > 0; ) {
meth_ent = get_Call_callee(succ, c);
/* unknown_entity is used to signal that we don't know what is called */
......@@ -89,7 +83,7 @@ static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
break;
}
for (p = n_params - 1; p >= 0; --p) {
for (size_t p = n_params; p-- > 0; ) {
if (get_Call_param(succ, p) == arg) {
/* an arg can be used more than once ! */
bits |= get_method_param_access(meth_ent, p);
......@@ -162,16 +156,8 @@ static ptr_access_kind analyze_arg(ir_node *arg, ptr_access_kind bits)
*/
static void analyze_ent_args(ir_entity *ent)
{
ir_graph *irg;
ir_node *irg_args, *arg;
ir_mode *arg_mode;
int nparams, i;
long proj_nr;
ir_type *mtp;
ptr_access_kind *rw_info;
mtp = get_entity_type(ent);
nparams = get_method_n_params(mtp);
ir_type *mtp = get_entity_type(ent);
size_t nparams = get_method_n_params(mtp);
ent->attr.mtd_attr.param_access = NEW_ARR_F(ptr_access_kind, nparams);
......@@ -181,37 +167,36 @@ static void analyze_ent_args(ir_entity *ent)
if (nparams <= 0)
return;
irg = get_entity_irg(ent);
/* we have not yet analyzed the graph, set ALL access for pointer args */
for (i = nparams - 1; i >= 0; --i) {
for (size_t i = nparams; i-- > 0; ) {
ir_type *type = get_method_param_type(mtp, i);
ent->attr.mtd_attr.param_access[i] = is_Pointer_type(type) ? ptr_access_all : ptr_access_none;
}
if (! irg) {
ir_graph *irg = get_entity_irg(ent);
if (irg == NULL) {
/* no graph, no better info */
return;
}
assure_irg_outs(irg);
irg_args = get_irg_args(irg);
ir_node *irg_args = get_irg_args(irg);
/* A array to save the information for each argument with
mode reference.*/
ptr_access_kind *rw_info;
NEW_ARR_A(ptr_access_kind, rw_info, nparams);
/* We initialize the element with none state. */
for (i = nparams - 1; i >= 0; --i)
for (size_t i = nparams; i-- > 0; )
rw_info[i] = ptr_access_none;
/* search for arguments with mode reference
to analyze them.*/
for (i = get_irn_n_outs(irg_args) - 1; i >= 0; --i) {
arg = get_irn_out(irg_args, i);
arg_mode = get_irn_mode(arg);
proj_nr = get_Proj_proj(arg);
for (int i = get_irn_n_outs(irg_args); i-- > 0; ) {
ir_node *arg = get_irn_out(irg_args, i);
ir_mode *arg_mode = get_irn_mode(arg);
long proj_nr = get_Proj_proj(arg);
if (mode_is_reference(arg_mode))
rw_info[proj_nr] |= analyze_arg(arg, rw_info[proj_nr]);
......@@ -219,30 +204,27 @@ static void analyze_ent_args(ir_entity *ent)
/* copy the temporary info */
memcpy(ent->attr.mtd_attr.param_access, rw_info,
nparams * sizeof(ent->attr.mtd_attr.param_access[0]));
nparams * sizeof(ent->attr.mtd_attr.param_access[0]));
}
void analyze_irg_args(ir_graph *irg)
{
ir_entity *ent;
if (irg == get_const_code_irg())
return;
ent = get_irg_entity(irg);
if (! ent)
ir_entity *entity = get_irg_entity(irg);
if (! entity)
return;
if (! ent->attr.mtd_attr.param_access)
analyze_ent_args(ent);
if (! entity->attr.mtd_attr.param_access)
analyze_ent_args(entity);
}
ptr_access_kind get_method_param_access(ir_entity *ent, size_t pos)
{
#ifndef NDEBUG
ir_type *mtp = get_entity_type(ent);
int is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
bool is_variadic = get_method_variadicity(mtp) == variadicity_variadic;
assert(is_variadic || pos < get_method_n_params(mtp));
#endif
......@@ -278,17 +260,12 @@ enum args_weight {
*/
static unsigned calc_method_param_weight(ir_node *arg)
{
int i, j, k;
ir_node *succ, *op;
unsigned weight = null_weight;
/* We mark the nodes to avoid endless recursion */
mark_irn_visited(arg);
for (i = get_irn_n_outs(arg) - 1; i >= 0; i--) {
succ = get_irn_out(arg, i);
/* We was here.*/
unsigned weight = null_weight;
for (int i = get_irn_n_outs(arg); i-- > 0; ) {
ir_node *succ = get_irn_out(arg, i);
if (irn_visited(succ))
continue;
......@@ -304,9 +281,10 @@ static unsigned calc_method_param_weight(ir_node *arg)
weight += indirect_call_weight;
}
break;
case iro_Cmp:
case iro_Cmp: {
/* We have reached a cmp and we must increase the
weight with the cmp_weight. */
ir_node *op;
if (get_Cmp_left(succ) == arg)
op = get_Cmp_right(succ);
else
......@@ -317,6 +295,7 @@ static unsigned calc_method_param_weight(ir_node *arg)
} else
weight += cmp_weight;
break;
}
case iro_Cond:
/* the argument is used for a SwitchCond, a big win */
weight += const_cmp_weight * get_irn_n_outs(succ);
......@@ -327,11 +306,11 @@ static unsigned calc_method_param_weight(ir_node *arg)
break;
case iro_Tuple:
/* unoptimized tuple */
for (j = get_Tuple_n_preds(succ) - 1; j >= 0; --j) {
for (int j = get_Tuple_n_preds(succ); j-- > 0; ) {
ir_node *pred = get_Tuple_pred(succ, j);
if (pred == arg) {
/* look for Proj(j) */
for (k = get_irn_n_outs(succ) - 1; k >= 0; --k) {
for (int k = get_irn_n_outs(succ); k-- > 0; ) {
ir_node *succ_succ = get_irn_out(succ, k);
if (is_Proj(succ_succ)) {
if (get_Proj_proj(succ_succ) == j) {
......@@ -352,6 +331,7 @@ static unsigned calc_method_param_weight(ir_node *arg)
BinOp is a constant we increase the weight with const_binop_weight
and call the function recursive.
*/
ir_node *op;
if (get_binop_left(succ) == arg)
op = get_binop_right(succ);
else
......@@ -383,15 +363,9 @@ static unsigned calc_method_param_weight(ir_node *arg)
*/
static void analyze_method_params_weight(ir_entity *ent)
{
ir_type *mtp;
ir_graph *irg;
int nparams, i, proj_nr;
ir_node *irg_args, *arg;
mtp = get_entity_type(ent);
nparams = get_method_n_params(mtp);
/* allocate a new array. currently used as 'analysed' flag */
ir_type *mtp = get_entity_type(ent);
size_t nparams = get_method_n_params(mtp);
ent->attr.mtd_attr.param_weight = NEW_ARR_F(unsigned, nparams);
/* If the method haven't parameters we have nothing to do. */
......@@ -399,10 +373,10 @@ static void analyze_method_params_weight(ir_entity *ent)
return;
/* First we initialize the parameter weights with 0. */
for (i = nparams - 1; i >= 0; i--)
for (size_t i = nparams; i-- > 0; )
ent->attr.mtd_attr.param_weight[i] = null_weight;
irg = get_entity_irg(ent);
ir_graph *irg = get_entity_irg(ent);
if (irg == NULL) {
/* no graph, no better info */
return;
......@@ -411,10 +385,10 @@ static void analyze_method_params_weight(ir_entity *ent)
/* Call algorithm that computes the out edges */
assure_irg_outs(irg);
irg_args = get_irg_args(irg);
for (i = get_irn_n_outs(irg_args) - 1; i >= 0; --i) {
arg = get_irn_out(irg_args, i);
proj_nr = get_Proj_proj(arg);
ir_node *irg_args = get_irg_args(irg);
for (int i = get_irn_n_outs(irg_args); i-- > 0; ) {
ir_node *arg = get_irn_out(irg_args, i);
long proj_nr = get_Proj_proj(arg);
ent->attr.mtd_attr.param_weight[proj_nr] += calc_method_param_weight(arg);
}
}
......
This diff is collapsed.
......@@ -69,8 +69,10 @@ static void add_cdep(ir_node *node, ir_node *dep_on)
ir_cdep *newdep;
for (;;) {
if (get_cdep_node(dep) == dep_on) return;
if (dep->next == NULL) break;
if (get_cdep_node(dep) == dep_on)
return;
if (dep->next == NULL)
break;
dep = dep->next;
}
newdep = OALLOC(&cdep_data->obst, ir_cdep);
......@@ -86,16 +88,14 @@ static void add_cdep(ir_node *node, ir_node *dep_on)
static void cdep_pre(ir_node *node, void *ctx)
{
(void)ctx;
for (int i = get_Block_n_cfgpreds(node); i-- != 0;) {
for (int i = get_Block_n_cfgpreds(node); i-- > 0; ) {
ir_node *pred = get_Block_cfgpred_block(node, i);
ir_node *pdom;
ir_node *dependee;
if (is_Bad(pred)) continue;
if (is_Bad(pred))
continue;
pdom = get_Block_ipostdom(pred);
for (dependee = node; dependee != pdom; dependee = get_Block_ipostdom(dependee)) {
ir_node *pdom = get_Block_ipostdom(pred);
for (ir_node *dependee = node; dependee != pdom;
dependee = get_Block_ipostdom(dependee)) {
assert(!is_Bad(pdom));
add_cdep(dependee, pred);
}
......@@ -108,15 +108,10 @@ static void cdep_pre(ir_node *node, void *ctx)
*/
static int cdep_edge_hook(FILE *F, ir_node *block)
{
ir_cdep *cd;
for (cd = find_cdep(block); cd != NULL; cd = cd->next) {
fprintf(
F,
"edge:{sourcename:\"n%ld\" targetname:\"n%ld\" "
"linestyle:dashed color:gold}\n",
get_irn_node_nr(block), get_irn_node_nr(cd->node)
);
for (ir_cdep *cd = find_cdep(block); cd != NULL; cd = cd->next) {
fprintf(F, "edge:{sourcename:\"n%ld\" targetname:\"n%ld\" "
"linestyle:dashed color:gold}\n",
get_irn_node_nr(block), get_irn_node_nr(cd->node));
}
return 0;
......@@ -162,10 +157,10 @@ void free_cdep(ir_graph *irg)
int is_cdep_on(const ir_node *dependee, const ir_node *candidate)
{
const ir_cdep *dep;
for (dep = find_cdep(dependee); dep != NULL; dep = dep->next) {
if (get_cdep_node(dep) == candidate) return 1;
for (const ir_cdep *dep = find_cdep(dependee); dep != NULL;
dep = dep->next) {
if (get_cdep_node(dep) == candidate)
return 1;
}
return 0;
}
......@@ -173,13 +168,11 @@ int is_cdep_on(const ir_node *dependee, const ir_node *candidate)
ir_node *get_unique_cdep(const ir_node *block)
{
ir_cdep *cdep = find_cdep(block);
return cdep != NULL && cdep->next == NULL ? get_cdep_node(cdep) : NULL;
}
int has_multiple_cdep(const ir_node *block)
{
ir_cdep *cdep = find_cdep(block);
return cdep != NULL && cdep->next != NULL;
}
......@@ -27,19 +27,17 @@
static int cmp_edge(const void *a, const void *b, size_t sz)
{
(void) sz;
const dfs_edge_t *p = (const dfs_edge_t*) a;
const dfs_edge_t *q = (const dfs_edge_t*) b;
(void) sz;
return !(p->src == q->src && p->tgt == q->tgt);
}
static int cmp_node(const void *a, const void *b, size_t sz)
{
(void) sz;
const dfs_node_t *p = (const dfs_node_t*) a;
const dfs_node_t *q = (const dfs_node_t*) b;
(void) sz;
return p->node != q->node;
}
......@@ -48,8 +46,8 @@ static int cmp_node(const void *a, const void *b, size_t sz)
static dfs_edge_t *get_edge(const dfs_t *self, const void *src, const void *tgt)
{
unsigned hash = hash_combine(hash_ptr(src), hash_ptr(tgt));
dfs_edge_t templ;
dfs_edge_t templ;
templ.src = src;
templ.tgt = tgt;
templ.kind = (dfs_edge_kind_t) -1;
......@@ -60,10 +58,7 @@ static dfs_edge_t *get_edge(const dfs_t *self, const void *src, const void *tgt)
static void dfs_perform(dfs_t *dfs, void *n, void *anc, int level)
{
dfs_node_t *node = get_node(dfs, n);
void **succs, **iter;
assert(node->visited == 0);
node->visited = 1;
node->node = n;
node->ancestor = anc;
......@@ -73,9 +68,9 @@ static void dfs_perform(dfs_t *dfs, void *n, void *anc, int level)
dfs->graph_impl->grow_succs(dfs->graph, n, &dfs->obst);
obstack_ptr_grow(&dfs->obst, NULL);
succs = (void**) obstack_finish(&dfs->obst);
void **succs = (void**) obstack_finish(&dfs->obst);
for (iter = succs; *iter; ++iter) {
for (void **iter = succs; *iter != NULL; ++iter) {
void *p = *iter;
/* get the node */
......@@ -201,11 +196,7 @@ void dfs_free(dfs_t *dfs)
static void dfs_dump_edge(const dfs_edge_t *edge, FILE *file)
{
dfs_node_t *src = edge->s;
dfs_node_t *tgt = edge->t;
const char *s, *style;
int weight;
const char *s;
#define XXX(e) case DFS_EDGE_ ## e: s = #e; break
switch (edge->kind) {
XXX(FWD);
......@@ -215,9 +206,11 @@ static void dfs_dump_edge(const dfs_edge_t *edge, FILE *file)
}
#undef XXX
weight = edge->kind == DFS_EDGE_BACK ? 1 : 1000;
style = edge->kind == DFS_EDGE_BACK ? "dashed" : "solid";
int weight = edge->kind == DFS_EDGE_BACK ? 1 : 1000;
const char *style = edge->kind == DFS_EDGE_BACK ? "dashed" : "solid";
dfs_node_t *src = edge->s;
dfs_node_t *tgt = edge->t;
ir_fprintf(file, "\tn%d -> n%d [label=\"%s\",style=\"%s\",weight=\"%d\"];\n", src->pre_num, tgt->pre_num, s, style, weight);
}
......@@ -225,7 +218,6 @@ static int node_level_cmp(const void *a, const void *b)
{
const dfs_node_t *p = *(const dfs_node_t **) a;
const dfs_node_t *q = *(const dfs_node_t **) b;
if (p->level == q->level)
return p->pre_num - q->pre_num;
return p->level - q->level;
......@@ -234,16 +226,16 @@ static int node_level_cmp(const void *a, const void *b)
void dfs_dump(const dfs_t *dfs, FILE *file)
{
dfs_node_t **nodes = XMALLOCN(dfs_node_t*, dfs->pre_num);
int i, n = 0;
ir_fprintf(file, "digraph G {\nranksep=0.5\n");
int n = 0;
foreach_set (dfs->nodes, dfs_node_t, node) {
nodes[n++] = node;
}
qsort(nodes, n, sizeof(nodes[0]), node_level_cmp);
i = 0;
int i = 0;
while (i < n) {
int level = nodes[i]->level;
......@@ -255,7 +247,7 @@ void dfs_dump(const dfs_t *dfs, FILE *file)
}
for (i = 0; i < n; ++i) {
for (int i = 0; i < n; ++i) {
dfs_node_t *const node = nodes[i];
ir_fprintf(file, "\tn%d [label=\"%d\"]\n", node->pre_num, get_Block_dom_tree_pre_num((ir_node*) node->node));
}
......
......@@ -40,7 +40,6 @@ static inline ir_node *get_idom(ir_node *bl)
*/
static ir_node **compute_df(ir_node *blk, ir_dom_front_info_t *info)
{
ir_node *c;
ir_node **df_list = NEW_ARR_F(ir_node *, 0);
/* Add local dominance frontiers */
......@@ -57,12 +56,12 @@ static ir_node **compute_df(ir_node *blk, ir_dom_front_info_t *info)
* into the dominance frontiers of the children, which are not
* dominated by the given block.
*/
for (c = get_Block_dominated_first(blk); c; c = get_Block_dominated_next(c)) {
size_t i;
for (ir_node *c = get_Block_dominated_first(blk); c != NULL;
c = get_Block_dominated_next(c)) {
ir_node **df_c_list = compute_df(c, info);
for (i = ARR_LEN(df_c_list); i > 0;) {
ir_node *w = df_c_list[--i];
for (size_t i = ARR_LEN(df_c_list); i-- > 0;) {
ir_node *w = df_c_list[i];
if (get_idom(w) != blk)
ARR_APP1(ir_node *, df_list, w);
}
......
......@@ -99,16 +99,15 @@ void exit_execfreq(void)
static double *solve_lgs(gs_matrix_t *mat, double *x, int size)
{
double init = 1.0 / size;
double dev;
int i, iter = 0;
/* better convergence. */
for (i = 0; i < size; ++i)
double init = 1.0 / size;
for (int i = 0; i < size; ++i)
x[i] = init;
stat_ev_dbl("execfreq_matrix_size", size);
stat_ev_tim_push();
int iter = 0;
double dev;
do {
++iter;
dev = gs_matrix_gauss_seidel(mat, x, size);
......
......@@ -70,10 +70,6 @@ static void height_dump_cb(void *data, FILE *f, const ir_node *irn)
*/
static bool search(ir_heights_t *h, const ir_node *curr, const ir_node *tgt)
{
irn_height_t *h_curr;
irn_height_t *h_tgt;
int i, n;
/* if the current node is the one we were looking for, we're done. */
if (curr == tgt)
return true;
......@@ -85,12 +81,12 @@ static bool search(ir_heights_t *h, const ir_node *curr, const ir_node *tgt)
return false;
/* Check, if we have already been here. Coming more often won't help :-) */
h_curr = maybe_get_height_data(h, curr);
irn_height_t *h_curr = maybe_get_height_data(h, curr);
if (h_curr->visited >= h->visited)
return false;
/* If we are too deep into the DAG we won't find the target either. */
h_tgt = maybe_get_height_data(h, tgt);
irn_height_t *h_tgt = maybe_get_height_data(h, tgt);
if (h_curr->height > h_tgt->height)
return false;
......@@ -98,7 +94,7 @@ static bool search(ir_heights_t *h, const ir_node *curr, const ir_node *tgt)
h_curr->visited = h->visited;
/* Start a search from this node. */
for (i = 0, n = get_irn_ins_or_deps(curr); i < n; ++i) {
for (int i = 0, n = get_irn_ins_or_deps(curr); i < n; ++i) {
ir_node *op = get_irn_in_or_dep(curr, i);
if (search(h, op, tgt))
return true;
......@@ -110,9 +106,9 @@ static bool search(ir_heights_t *h, const ir_node *curr, const ir_node *tgt)
int heights_reachable_in_block(ir_heights_t *h, const ir_node *n,
const ir_node *m)
{
int res = 0;
irn_height_t *hn = maybe_get_height_data(h, n);
irn_height_t *hm = maybe_get_height_data(h, m);
int res = 0;
irn_height_t *hn = maybe_get_height_data(h, n);
irn_height_t *hm = maybe_get_height_data(h, m);
assert(get_nodes_block(n) == get_nodes_block(m));
assert(hn != NULL && hm != NULL);
......@@ -170,10 +166,9 @@ static unsigned compute_height(ir_heights_t *h, ir_node *irn, const ir_node *bl)
static unsigned compute_heights_in_block(ir_node *bl, ir_heights_t *h)
{
int max_height = -1;
h->visited++;
int max_height = -1;
foreach_out_edge(bl, edge) {
ir_node *dep = get_edge_src_irn(edge);
int curh = compute_height(h, dep, bl);
......@@ -200,14 +195,13 @@ static void compute_heights_in_block_walker(ir_node *block, void *data)
unsigned get_irn_height(const ir_heights_t *heights, const ir_node *irn)
{
const irn_height_t *height = maybe_get_height_data(heights, irn);
assert(height != NULL && "No height information for node");
assert(height != NULL);
return height->height;
}
unsigned heights_recompute_block(ir_heights_t *h, ir_node *block)
{
ir_graph *irg = get_irn_irg(block);
assure_edges(irg);
/* reset data for all nodes in the block */
......
......@@ -32,12 +32,13 @@ static bitset_t *mere_get_backarray(const ir_node *n)
{
switch (get_irn_opcode(n)) {
case iro_Block:
if (!get_Block_matured(n)) return NULL;
if (!get_Block_matured(n))
return NULL;
assert(n->attr.block.backedge && "backedge array not allocated!");
assert(n->attr.block.backedge != NULL);
return n->attr.block.backedge;
case iro_Phi:
assert(n->attr.phi.u.backedge && "backedge array not allocated!");
assert(n->attr.phi.u.backedge != NULL);
return n->attr.phi.u.backedge;
default:
break;
......@@ -52,12 +53,11 @@ static bitset_t *mere_get_backarray(const ir_node *n)
static bitset_t *get_backarray(const ir_node *n)
{
bitset_t *ba = mere_get_backarray(n);
#ifndef NDEBUG
if (ba) {
if (ba != NULL) {
size_t bal = bitset_size(ba); /* avoid macro expansion in assertion. */
size_t inl = get_irn_arity(n);
assert(bal == inl && "backedge array with faulty length");
assert(bal == inl);
}
#endif
......@@ -81,17 +81,14 @@ static int legal_backarray(const ir_node *n)
void fix_backedges(struct obstack *obst, ir_node *n)