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.

diff --git a/include/libfirm/iroptimize.h b/include/libfirm/iroptimize.h
index 793f8a4..f2d7a28 100644 (file)
--- a/include/libfirm/iroptimize.h
+++ b/include/libfirm/iroptimize.h
@@ -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 */

diff --git a/ir/opt/opt_inline.c b/ir/opt/opt_inline.c
index dfbb539..43dba4b 100644 (file)
--- a/ir/opt/opt_inline.c
+++ b/ir/opt/opt_inline.c
@@ -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);