Commit eff21a4b authored by Andreas Zwinkau's avatar Andreas Zwinkau
Browse files

leave -> leaf

One of the green things on plants is a 'leaf'.
A 'leave', would be a vacation.

For the plural of 'leaf', 'leaves' is more common,
but 'leafs' is also correct and more regular.
parent 5474a1c1
......@@ -753,8 +753,8 @@ FIRM_API ir_graph_pass_t *inline_small_irgs_pass(const char *name, int size);
/**
* Inlineing with a different heuristic than inline_small_irgs().
*
* Inlines leave functions. If inlining creates new leave
* function inlines these, too. (If g calls f, and f calls leave h,
* Inlines leaf functions. If inlining creates new leafs
* function inlines these, too. (If g calls f, and f calls leaf h,
* h is first inlined in f and then f in g.)
*
* Then inlines all small functions (this is not recursive).
......@@ -767,32 +767,32 @@ FIRM_API ir_graph_pass_t *inline_small_irgs_pass(const char *name, int size);
* @param maxsize Do not inline any calls if a method has more than
* maxsize firm nodes. It may reach this limit by
* inlining.
* @param leavesize Inline leave functions if they have less than leavesize
* @param leafsize Inline leaf functions if they have less than leafsize
* nodes.
* @param size Inline all function smaller than size.
* @param ignore_runtime count a function only calling runtime functions as
* leave
* leaf
*/
FIRM_API void inline_leave_functions(unsigned maxsize, unsigned leavesize,
FIRM_API void inline_leaf_functions(unsigned maxsize, unsigned leafsize,
unsigned size, int ignore_runtime);
/**
* Creates an ir_prog pass for inline_leave_functions().
* Creates an ir_prog pass for inline_leaf_functions().
*
* @param name the name of this pass or NULL
* @param maxsize Do not inline any calls if a method has more than
* maxsize firm nodes. It may reach this limit by
* inlining.
* @param leavesize Inline leave functions if they have less than leavesize
* @param leafsize Inline leaf functions if they have less than leafsize
* nodes.
* @param size Inline all function smaller than size.
* @param ignore_runtime count a function only calling runtime functions as
* leave
* leaf
*
* @return the newly created ir_prog pass
*/
FIRM_API ir_prog_pass_t *inline_leave_functions_pass(const char *name,
unsigned maxsize, unsigned leavesize, unsigned size,
FIRM_API ir_prog_pass_t *inline_leaf_functions_pass(const char *name,
unsigned maxsize, unsigned leafsize, unsigned size,
int ignore_runtime);
/** pointer to an optimization function */
......
......@@ -890,9 +890,9 @@ static void collect_calls2(ir_node *call, void *ctx)
/**
* Returns TRUE if the number of callers is 0 in the irg's environment,
* hence this irg is a leave.
* hence this irg is a leaf.
*/
inline static int is_leave(ir_graph *irg)
inline static int is_leaf(ir_graph *irg)
{
inline_irg_env *env = (inline_irg_env*)get_irg_link(irg);
return env->n_call_nodes == 0;
......@@ -954,14 +954,14 @@ static void append_call_list(inline_irg_env *dst, inline_irg_env *src, int loop_
}
/*
* Inlines small leave methods at call sites where the called address comes
* Inlines small leaf methods at call sites where the called address comes
* from a Const node that references the entity representing the called
* method.
* The size argument is a rough measure for the code size of the method:
* Methods where the obstack containing the firm graph is smaller than
* size are inlined.
*/
void inline_leave_functions(unsigned maxsize, unsigned leavesize,
void inline_leaf_functions(unsigned maxsize, unsigned leafsize,
unsigned size, int ignore_runtime)
{
inline_irg_env *env;
......@@ -1002,7 +1002,7 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
/* -- and now inline. -- */
/* Inline leaves recursively -- we might construct new leaves. */
/* Inline leafs recursively -- we might construct new leafs. */
do {
did_inline = 0;
......@@ -1029,8 +1029,8 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
continue;
}
if (is_leave(callee) && (
is_smaller(callee, leavesize) || prop >= irg_inline_forced)) {
if (is_leaf(callee) && (
is_smaller(callee, leafsize) || prop >= irg_inline_forced)) {
if (!phiproj_computed) {
phiproj_computed = 1;
collect_phiprojs(current_ir_graph);
......@@ -1108,7 +1108,7 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
/*
* No copy yet, create one.
* Note that recursive methods are never leaves, so it is sufficient
* Note that recursive methods are never leafs, so it is sufficient
* to test this condition here.
*/
copy = create_irg_copy(callee);
......@@ -1204,44 +1204,44 @@ void inline_leave_functions(unsigned maxsize, unsigned leavesize,
current_ir_graph = rem;
}
typedef struct inline_leave_functions_pass_t {
typedef struct inline_leaf_functions_pass_t {
ir_prog_pass_t pass;
unsigned maxsize;
unsigned leavesize;
unsigned leafsize;
unsigned size;
int ignore_runtime;
} inline_leave_functions_pass_t;
} inline_leaf_functions_pass_t;
/**
* Wrapper to run inline_leave_functions() as a ir_prog pass.
* Wrapper to run inline_leaf_functions() as a ir_prog pass.
*/
static int inline_leave_functions_wrapper(ir_prog *irp, void *context)
static int inline_leaf_functions_wrapper(ir_prog *irp, void *context)
{
inline_leave_functions_pass_t *pass = (inline_leave_functions_pass_t*)context;
inline_leaf_functions_pass_t *pass = (inline_leaf_functions_pass_t*)context;
(void)irp;
inline_leave_functions(
pass->maxsize, pass->leavesize,
inline_leaf_functions(
pass->maxsize, pass->leafsize,
pass->size, pass->ignore_runtime);
return 0;
}
/* create a pass for inline_leave_functions() */
ir_prog_pass_t *inline_leave_functions_pass(
const char *name, unsigned maxsize, unsigned leavesize,
/* create a pass for inline_leaf_functions() */
ir_prog_pass_t *inline_leaf_functions_pass(
const char *name, unsigned maxsize, unsigned leafsize,
unsigned size, int ignore_runtime)
{
inline_leave_functions_pass_t *pass = XMALLOCZ(inline_leave_functions_pass_t);
inline_leaf_functions_pass_t *pass = XMALLOCZ(inline_leaf_functions_pass_t);
pass->maxsize = maxsize;
pass->leavesize = leavesize;
pass->leafsize = leafsize;
pass->size = size;
pass->ignore_runtime = ignore_runtime;
return def_prog_pass_constructor(
&pass->pass,
name ? name : "inline_leave_functions",
inline_leave_functions_wrapper);
name ? name : "inline_leaf_functions",
inline_leaf_functions_wrapper);
}
/**
......@@ -1462,7 +1462,7 @@ static int calc_inline_benefice(call_entry *entry, ir_graph *callee)
if (callee_env->n_nodes < 30 && !callee_env->recursive)
weight += 2000;
/* and finally for leaves: they do not increase the register pressure
/* and finally for leafs: they do not increase the register pressure
because of callee safe registers */
if (callee_env->n_call_nodes == 0)
weight += 400;
......@@ -1646,7 +1646,7 @@ static void inline_into(ir_graph *irg, unsigned maxsize,
/*
* No copy yet, create one.
* Note that recursive methods are never leaves, so it is
* Note that recursive methods are never leafs, so it is
* sufficient to test this condition here.
*/
copy = create_irg_copy(callee);
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment