Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Use prototype syntax in function definitions.

Use prototype syntax in function definitions, not just function
declarations.  This means that some forward declarations are no longer
necessary; remove them.
  • Loading branch information...
commit 9d1b64fb403be10cf805914fac8c634010f0213c 1 parent 2ae1134
Jakub Zawadzki authored guyharris committed
Showing with 46 additions and 146 deletions.
  1. +46 −146 optimize.c
192 optimize.c
View
@@ -112,51 +112,9 @@ static int cur_mark;
static void opt_init(struct block *);
static void opt_cleanup(void);
-static void make_marks(struct block *);
-static void mark_code(struct block *);
-
static void intern_blocks(struct block *);
-static int eq_slist(struct slist *, struct slist *);
-
-static void find_levels_r(struct block *);
-
-static void find_levels(struct block *);
-static void find_dom(struct block *);
-static void propedom(struct edge *);
-static void find_edom(struct block *);
-static void find_closure(struct block *);
-static int atomuse(struct stmt *);
-static int atomdef(struct stmt *);
-static void compute_local_ud(struct block *);
-static void find_ud(struct block *);
-static void init_val(void);
-static int F(int, int, int);
-static inline void vstore(struct stmt *, int *, int, int);
-static void opt_blk(struct block *, int);
-static int use_conflict(struct block *, struct block *);
-static void opt_j(struct edge *);
-static void or_pullup(struct block *);
-static void and_pullup(struct block *);
-static void opt_blks(struct block *, int);
-static inline void link_inedge(struct edge *, struct block *);
static void find_inedges(struct block *);
-static void opt_root(struct block **);
-static void opt_loop(struct block *, int);
-static void fold_op(struct stmt *, int, int);
-static inline struct slist *this_op(struct slist *);
-static void opt_not(struct block *);
-static void opt_peep(struct block *);
-static void opt_stmt(struct stmt *, int[], int);
-static void deadstmt(struct stmt *, struct stmt *[]);
-static void opt_deadstores(struct block *);
-static struct block *fold_edge(struct block *, struct edge *);
-static inline int eq_blk(struct block *, struct block *);
-static u_int slength(struct slist *);
-static int count_blocks(struct block *);
-static void number_blks_r(struct block *);
-static u_int count_stmts(struct block *);
-static int convert_code_r(struct block *);
#ifdef BDEBUG
static void opt_dump(struct block *);
#endif
@@ -232,8 +190,7 @@ static uset all_edge_sets;
#endif
static void
-find_levels_r(b)
- struct block *b;
+find_levels_r(struct block *b)
{
int level;
@@ -261,8 +218,7 @@ find_levels_r(b)
* with the 'link' field of the struct block.
*/
static void
-find_levels(root)
- struct block *root;
+find_levels(struct block *root)
{
memset((char *)levels, 0, n_blocks * sizeof(*levels));
unMarkAll();
@@ -274,8 +230,7 @@ find_levels(root)
* Assumes graph has been leveled.
*/
static void
-find_dom(root)
- struct block *root;
+find_dom(struct block *root)
{
int i;
struct block *b;
@@ -305,8 +260,7 @@ find_dom(root)
}
static void
-propedom(ep)
- struct edge *ep;
+propedom(struct edge *ep)
{
SET_INSERT(ep->edom, ep->id);
if (ep->succ) {
@@ -320,8 +274,7 @@ propedom(ep)
* Assumes graph has been leveled and predecessors established.
*/
static void
-find_edom(root)
- struct block *root;
+find_edom(struct block *root)
{
int i;
uset x;
@@ -350,8 +303,7 @@ find_edom(root)
* Assumes graph has been leveled.
*/
static void
-find_closure(root)
- struct block *root;
+find_closure(struct block *root)
{
int i;
struct block *b;
@@ -381,8 +333,7 @@ find_closure(root)
* The implementation should probably change to an array access.
*/
static int
-atomuse(s)
- struct stmt *s;
+atomuse(struct stmt *s)
{
register int c = s->code;
@@ -427,8 +378,7 @@ atomuse(s)
* The implementation should probably change to an array access.
*/
static int
-atomdef(s)
- struct stmt *s;
+atomdef(struct stmt *s)
{
if (s->code == NOP)
return -1;
@@ -464,8 +414,7 @@ atomdef(s)
* register by a predecessor block of this block.
*/
static void
-compute_local_ud(b)
- struct block *b;
+compute_local_ud(struct block *b)
{
struct slist *s;
atomset def = 0, use = 0, kill = 0;
@@ -526,8 +475,7 @@ compute_local_ud(b)
* Assume graph is already leveled.
*/
static void
-find_ud(root)
- struct block *root;
+find_ud(struct block *root)
{
int i, maxlevel;
struct block *p;
@@ -582,7 +530,7 @@ struct valnode *vnode_base;
struct valnode *next_vnode;
static void
-init_val()
+init_val(void)
{
curval = 0;
next_vnode = vnode_base;
@@ -592,9 +540,7 @@ init_val()
/* Because we really don't have an IR, this stuff is a little messy. */
static int
-F(code, v0, v1)
- int code;
- int v0, v1;
+F(int code, int v0, int v1)
{
u_int hash;
int val;
@@ -625,11 +571,7 @@ F(code, v0, v1)
}
static inline void
-vstore(s, valp, newval, alter)
- struct stmt *s;
- int *valp;
- int newval;
- int alter;
+vstore(struct stmt *s, int *valp, int newval, int alter)
{
if (alter && *valp == newval)
s->code = NOP;
@@ -638,9 +580,7 @@ vstore(s, valp, newval, alter)
}
static void
-fold_op(s, v0, v1)
- struct stmt *s;
- int v0, v1;
+fold_op(struct stmt *s, int v0, int v1)
{
bpf_u_int32 a, b;
@@ -695,8 +635,7 @@ fold_op(s, v0, v1)
}
static inline struct slist *
-this_op(s)
- struct slist *s;
+this_op(struct slist *s)
{
while (s != 0 && s->s.code == NOP)
s = s->next;
@@ -704,8 +643,7 @@ this_op(s)
}
static void
-opt_not(b)
- struct block *b;
+opt_not(struct block *b)
{
struct block *tmp = JT(b);
@@ -714,8 +652,7 @@ opt_not(b)
}
static void
-opt_peep(b)
- struct block *b;
+opt_peep(struct block *b)
{
struct slist *s;
struct slist *next, *last;
@@ -978,10 +915,7 @@ opt_peep(b)
* evaluation and code transformations weren't folded together.
*/
static void
-opt_stmt(s, val, alter)
- struct stmt *s;
- int val[];
- int alter;
+opt_stmt(struct stmt *s, int val[], int alter)
{
int op;
int v;
@@ -1166,9 +1100,7 @@ opt_stmt(s, val, alter)
}
static void
-deadstmt(s, last)
- register struct stmt *s;
- register struct stmt *last[];
+deadstmt(register struct stmt *s, register struct stmt *last[])
{
register int atom;
@@ -1192,8 +1124,7 @@ deadstmt(s, last)
}
static void
-opt_deadstores(b)
- register struct block *b;
+opt_deadstores(register struct block *b)
{
register struct slist *s;
register int atom;
@@ -1213,9 +1144,7 @@ opt_deadstores(b)
}
static void
-opt_blk(b, do_stmts)
- struct block *b;
- int do_stmts;
+opt_blk(struct block *b, int do_stmts)
{
struct slist *s;
struct edge *p;
@@ -1319,8 +1248,7 @@ opt_blk(b, do_stmts)
* from 'b'.
*/
static int
-use_conflict(b, succ)
- struct block *b, *succ;
+use_conflict(struct block *b, struct block *succ)
{
int atom;
atomset use = succ->out_use;
@@ -1336,9 +1264,7 @@ use_conflict(b, succ)
}
static struct block *
-fold_edge(child, ep)
- struct block *child;
- struct edge *ep;
+fold_edge(struct block *child, struct edge *ep)
{
int sense;
int aval0, aval1, oval0, oval1;
@@ -1390,8 +1316,7 @@ fold_edge(child, ep)
}
static void
-opt_j(ep)
- struct edge *ep;
+opt_j(struct edge *ep)
{
register int i, k;
register struct block *target;
@@ -1446,8 +1371,7 @@ opt_j(ep)
static void
-or_pullup(b)
- struct block *b;
+or_pullup(struct block *b)
{
int val, at_top;
struct block *pull;
@@ -1539,8 +1463,7 @@ or_pullup(b)
}
static void
-and_pullup(b)
- struct block *b;
+and_pullup(struct block *b)
{
int val, at_top;
struct block *pull;
@@ -1631,9 +1554,7 @@ and_pullup(b)
}
static void
-opt_blks(root, do_stmts)
- struct block *root;
- int do_stmts;
+opt_blks(struct block *root, int do_stmts)
{
int i, maxlevel;
struct block *p;
@@ -1670,17 +1591,14 @@ opt_blks(root, do_stmts)
}
static inline void
-link_inedge(parent, child)
- struct edge *parent;
- struct block *child;
+link_inedge(struct edge *parent, struct block *child)
{
parent->next = child->in_edges;
child->in_edges = parent;
}
static void
-find_inedges(root)
- struct block *root;
+find_inedges(struct block *root)
{
int i;
struct block *b;
@@ -1701,8 +1619,7 @@ find_inedges(root)
}
static void
-opt_root(b)
- struct block **b;
+opt_root(struct block **b)
{
struct slist *tmp, *s;
@@ -1726,9 +1643,7 @@ opt_root(b)
}
static void
-opt_loop(root, do_stmts)
- struct block *root;
- int do_stmts;
+opt_loop(struct block *root, int do_stmts)
{
#ifdef BDEBUG
@@ -1758,8 +1673,7 @@ opt_loop(root, do_stmts)
* Optimize the filter code in its dag representation.
*/
void
-bpf_optimize(rootp)
- struct block **rootp;
+bpf_optimize(struct block **rootp)
{
struct block *root;
@@ -1786,8 +1700,7 @@ bpf_optimize(rootp)
}
static void
-make_marks(p)
- struct block *p;
+make_marks(struct block *p)
{
if (!isMarked(p)) {
Mark(p);
@@ -1803,8 +1716,7 @@ make_marks(p)
* only for nodes that are alive.
*/
static void
-mark_code(p)
- struct block *p;
+mark_code(struct block *p)
{
cur_mark += 1;
make_marks(p);
@@ -1815,8 +1727,7 @@ mark_code(p)
* the accumulator.
*/
static int
-eq_slist(x, y)
- struct slist *x, *y;
+eq_slist(struct slist *x, struct slist *y)
{
while (1) {
while (x && x->s.code == NOP)
@@ -1835,8 +1746,7 @@ eq_slist(x, y)
}
static inline int
-eq_blk(b0, b1)
- struct block *b0, *b1;
+eq_blk(struct block *b0, struct block *b1)
{
if (b0->s.code == b1->s.code &&
b0->s.k == b1->s.k &&
@@ -1847,8 +1757,7 @@ eq_blk(b0, b1)
}
static void
-intern_blocks(root)
- struct block *root;
+intern_blocks(struct block *root)
{
struct block *p;
int i, j;
@@ -1891,7 +1800,7 @@ intern_blocks(root)
}
static void
-opt_cleanup()
+opt_cleanup(void)
{
free((void *)vnode_base);
free((void *)vmap);
@@ -1905,8 +1814,7 @@ opt_cleanup()
* Return the number of stmts in 's'.
*/
static u_int
-slength(s)
- struct slist *s;
+slength(struct slist *s)
{
u_int n = 0;
@@ -1921,8 +1829,7 @@ slength(s)
* All nodes should be initially unmarked.
*/
static int
-count_blocks(p)
- struct block *p;
+count_blocks(struct block *p)
{
if (p == 0 || isMarked(p))
return 0;
@@ -1935,8 +1842,7 @@ count_blocks(p)
* the basic blocks, and entering them into the 'blocks' array.`
*/
static void
-number_blks_r(p)
- struct block *p;
+number_blks_r(struct block *p)
{
int n;
@@ -1971,8 +1877,7 @@ number_blks_r(p)
* an extra long jump if the false branch requires it (p->longjf).
*/
static u_int
-count_stmts(p)
- struct block *p;
+count_stmts(struct block *p)
{
u_int n;
@@ -1989,8 +1894,7 @@ count_stmts(p)
* from the total number of blocks and/or statements.
*/
static void
-opt_init(root)
- struct block *root;
+opt_init(struct block *root)
{
bpf_u_int32 *p;
int i, n, max_stmts;
@@ -2088,8 +1992,7 @@ int bids[1000];
* properly.
*/
static int
-convert_code_r(p)
- struct block *p;
+convert_code_r(struct block *p)
{
struct bpf_insn *dst;
struct slist *src;
@@ -2261,9 +2164,7 @@ convert_code_r(p)
* done with the filter program. See the pcap man page.
*/
struct bpf_insn *
-icode_to_fcode(root, lenp)
- struct block *root;
- u_int *lenp;
+icode_to_fcode(struct block *root, u_int *lenp)
{
u_int n;
struct bpf_insn *fp;
@@ -2333,8 +2234,7 @@ install_bpf_program(pcap_t *p, struct bpf_program *fp)
#ifdef BDEBUG
static void
-opt_dump(root)
- struct block *root;
+opt_dump(struct block *root)
{
struct bpf_program f;
Please sign in to comment.
Something went wrong with that request. Please try again.