This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[tuples] Rename gimple_build_* to build_gimple_*
- From: Diego Novillo <dnovillo at google dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Wed, 25 Jul 2007 14:41:53 -0400
- Subject: [tuples] Rename gimple_build_* to build_gimple_*
Picky, picky, picky.
No functional changes, just the names reversed.
2007-07-25 Diego Novillo <dnovillo@google.com>
* tree-gimple.h (build_gimple_eh_filter_tree): Rename from
gimple_build_eh_filter_tree.
* gimple.h (build_gimple_return): Rename from gimple_build_return.
(build_gimple_assign): Rename from gimple_build_assign.
(build_gimple_call_vec): Rename from gimple_build_call_vec.
(build_gimple_call): Rename from gimple_build_call.
(build_gimple_label): Rename from gimple_build_label.
(build_gimple_goto): Rename from gimple_build_goto.
(build_gimple_nop): Rename from gimple_build_nop.
(build_gimple_bind): Rename from gimple_build_bind.
(build_gimple_asm): Rename from gimple_build_asm.
(build_gimple_catch): Rename from gimple_build_catch.
(build_gimple_eh_filter): Rename from gimple_build_eh_filter.
(build_gimple_try): Rename from gimple_build_try.
(build_gimple_phi): Rename from gimple_build_phi.
(build_gimple_resx): Rename from gimple_build_resx.
(build_gimple_switch): Rename from gimple_build_switch.
(build_gimple_switch_vec): Rename from gimple_build_switch_vec.
(build_gimple_omp_parallel): Rename from gimple_build_omp_parallel.
(build_gimple_omp_for): Rename from gimple_build_omp_for.
(build_gimple_omp_critical): Rename from gimple_build_omp_critical.
(build_gimple_omp_section): Rename from gimple_build_omp_section.
(build_gimple_omp_continue): Rename from gimple_build_omp_continue.
(build_gimple_omp_master): Rename from gimple_build_omp_master.
(build_gimple_omp_return): Rename from gimple_build_omp_return.
(build_gimple_omp_ordered): Rename from gimple_build_omp_ordered.
(build_gimple_omp_sections): Rename from gimple_build_omp_sections.
(build_gimple_omp_single): Rename from gimple_build_omp_single.
Update all users.
Index: tree-gimple.h
===================================================================
--- tree-gimple.h (revision 126917)
+++ tree-gimple.h (working copy)
@@ -132,7 +132,7 @@ extern void gimplify_and_add (tree, gimp
extern void gimple_add_tmp_var (tree);
extern gimple gimple_current_bind_expr (void);
extern tree voidify_wrapper_expr (tree, tree);
-extern tree gimple_build_eh_filter_tree (tree, tree, tree);
+extern tree build_gimple_eh_filter_tree (tree, tree, tree);
extern tree build_and_jump (tree *);
extern tree alloc_stmt_list (void);
extern void free_stmt_list (tree);
Index: gimplify.c
===================================================================
--- gimplify.c (revision 126917)
+++ gimplify.c (working copy)
@@ -921,7 +921,7 @@ unshare_expr (tree expr)
specification. */
tree
-gimple_build_eh_filter_tree (tree body, tree allowed, tree failure)
+build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)
{
tree t;
@@ -1026,11 +1026,11 @@ build_stack_save_restore (gimple *save,
{
tree tmp_var;
- *save = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
+ *save = build_gimple_call (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
gimple_call_set_lhs (*save, tmp_var);
- *restore = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
+ *restore = build_gimple_call (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1, tmp_var);
}
@@ -1075,7 +1075,7 @@ gimplify_bind_expr (tree *expr_p, gimple
DECL_GIMPLE_REG_P (t) = 1;
}
- gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL);
+ gimple_bind = build_gimple_bind (BIND_EXPR_VARS (bind_expr), NULL);
gimple_push_bind_expr (gimple_bind);
gimplify_ctxp->save_stack = false;
@@ -1092,7 +1092,7 @@ gimplify_bind_expr (tree *expr_p, gimple
format of the emitted code: see mx_register_decls(). */
build_stack_save_restore (&stack_save, &stack_restore);
- gs = gimple_build_try (gimple_bind_body (gimple_bind), NULL,
+ gs = build_gimple_try (gimple_bind_body (gimple_bind), NULL,
GIMPLE_TRY_FINALLY);
gimple_add (gimple_try_cleanup (gs), stack_restore);
@@ -1134,7 +1134,7 @@ gimplify_return_expr (tree stmt, gimple_
|| ret_expr == error_mark_node)
{
gimple_add (pre_p,
- gimple_build_return (ret_expr
+ build_gimple_return (ret_expr
&& TREE_CODE (ret_expr) == RESULT_DECL,
ret_expr));
return GS_ALL_DONE;
@@ -1198,7 +1198,7 @@ gimplify_return_expr (tree stmt, gimple_
else
ret_expr = build_gimple_modify_stmt (result_decl, result);
- gimple_add (pre_p, gimple_build_return (result == result_decl, ret_expr));
+ gimple_add (pre_p, build_gimple_return (result == result_decl, ret_expr));
return GS_ALL_DONE;
}
@@ -1296,16 +1296,16 @@ gimplify_loop_expr (tree *expr_p, gimple
tree saved_label = gimplify_ctxp->exit_label;
tree start_label = create_artificial_label ();
- gimple_add (pre_p, gimple_build_label (start_label));
+ gimple_add (pre_p, build_gimple_label (start_label));
gimplify_ctxp->exit_label = NULL_TREE;
gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
- gimple_add (pre_p, gimple_build_goto (start_label));
+ gimple_add (pre_p, build_gimple_goto (start_label));
if (gimplify_ctxp->exit_label)
- gimple_add (pre_p, gimple_build_label (gimplify_ctxp->exit_label));
+ gimple_add (pre_p, build_gimple_label (gimplify_ctxp->exit_label));
gimplify_ctxp->exit_label = saved_label;
@@ -1460,7 +1460,7 @@ gimplify_switch_expr (tree *expr_p, gimp
{
/* If the switch has no default label, add one, so that we jump
around the switch body. */
- gimple new_default = gimple_build_label (build3 (CASE_LABEL_EXPR,
+ gimple new_default = build_gimple_label (build3 (CASE_LABEL_EXPR,
void_type_node,
NULL_TREE,
NULL_TREE,
@@ -1470,7 +1470,7 @@ gimplify_switch_expr (tree *expr_p, gimp
}
sort_case_labels (labels);
- gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
+ gimple_switch = build_gimple_switch_vec (SWITCH_COND (switch_expr),
default_case, labels);
gimple_add (pre_p, gimple_switch);
gimple_seq_append (pre_p, switch_body_seq);
@@ -1494,7 +1494,7 @@ gimplify_case_label_expr (tree *expr_p,
if (ctxp->case_labels)
break;
- gimple gimple_label = gimple_build_label (*expr_p);
+ gimple gimple_label = build_gimple_label (*expr_p);
VEC_safe_push (tree, heap, ctxp->case_labels,
gimple_label_label (gimple_label));
gimple_add (pre_p, gimple_label);
@@ -2258,7 +2258,7 @@ gimplify_call_expr (tree *expr_p, gimple
/* Now add the GIMPLE call to PRE_P. If WANT_VALUE is set, we need
to create the appropriate temporary for the call's LHS. */
- call = gimple_build_call_vec (fndecl ? fndecl : CALL_EXPR_FN (*expr_p), args);
+ call = build_gimple_call_vec (fndecl ? fndecl : CALL_EXPR_FN (*expr_p), args);
gimple_add (pre_p, call);
if (want_value)
{
@@ -2696,24 +2696,24 @@ gimplify_cond_expr (tree *expr_p, gimple
{
arm1 = TREE_OPERAND (TREE_OPERAND (expr, 0), 0);
arm2 = TREE_OPERAND (TREE_OPERAND (expr, 0), 1);
- gimple_cond = gimple_build_cond (pred, arm1, arm2, label_false,
+ gimple_cond = build_gimple_cond (pred, arm1, arm2, label_false,
label_true);
}
else
{
/* Use canonical comparison with false. */
- gimple_cond = gimple_build_cond (pred, arm1, arm2, label_true,
+ gimple_cond = build_gimple_cond (pred, arm1, arm2, label_true,
label_false);
}
gimple_add (pre_p, gimple_cond);
- gimple_add (pre_p, gimple_build_label (label_true));
+ gimple_add (pre_p, build_gimple_label (label_true));
have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), pre_p);
label_cont = create_artificial_label ();
- gimple_add (pre_p, gimple_build_goto (label_cont));
- gimple_add (pre_p, gimple_build_label (label_false));
+ gimple_add (pre_p, build_gimple_goto (label_cont));
+ gimple_add (pre_p, build_gimple_label (label_false));
have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), pre_p);
- gimple_add (pre_p, gimple_build_label (label_cont));
+ gimple_add (pre_p, build_gimple_label (label_cont));
gimple_pop_condition (pre_p);
@@ -2754,7 +2754,7 @@ gimplify_modify_expr_to_memcpy (tree *ex
to_ptr = build_fold_addr_expr (to);
t = implicit_built_in_decls[BUILT_IN_MEMCPY];
- gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
+ gs = build_gimple_call (t, 3, to_ptr, from_ptr, size);
if (want_value)
{
@@ -2788,7 +2788,7 @@ gimplify_modify_expr_to_memset (tree *ex
to_ptr = build_fold_addr_expr (to);
t = implicit_built_in_decls[BUILT_IN_MEMSET];
- gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
+ gs = build_gimple_call (t, 3, to_ptr, integer_zero_node, size);
if (want_value)
{
@@ -2964,10 +2964,10 @@ gimplify_init_ctor_eval_range (tree obje
/* Create and initialize the index variable. */
var_type = TREE_TYPE (upper);
var = create_tmp_var (var_type, NULL);
- gimple_add (pre_p, gimple_build_assign (var, lower));
+ gimple_add (pre_p, build_gimple_assign (var, lower));
/* Add the loop entry label. */
- gimple_add (pre_p, gimple_build_label (loop_entry_label));
+ gimple_add (pre_p, build_gimple_label (loop_entry_label));
/* Build the reference. */
cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
@@ -2982,23 +2982,23 @@ gimplify_init_ctor_eval_range (tree obje
gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
pre_p, cleared);
else
- gimple_add (pre_p, gimple_build_assign (cref, value));
+ gimple_add (pre_p, build_gimple_assign (cref, value));
/* We exit the loop when the index var is equal to the upper bound. */
gimple_add (pre_p,
- gimple_build_cond (GIMPLE_COND_EQ, var, upper, loop_exit_label,
+ build_gimple_cond (GIMPLE_COND_EQ, var, upper, loop_exit_label,
NULL_TREE));
/* Otherwise, increment the index var... */
tmp = build2 (PLUS_EXPR, var_type, var,
fold_convert (var_type, integer_one_node));
- gimple_add (pre_p, gimple_build_assign (var, tmp));
+ gimple_add (pre_p, build_gimple_assign (var, tmp));
/* ...and jump back to the loop entry. */
- gimple_add (pre_p, gimple_build_goto (loop_entry_label));
+ gimple_add (pre_p, build_gimple_goto (loop_entry_label));
/* Add the loop exit label. */
- gimple_add (pre_p, gimple_build_label (loop_exit_label));
+ gimple_add (pre_p, build_gimple_label (loop_exit_label));
}
/* Return true if FDECL is accessing a field that is zero sized. */
@@ -3099,7 +3099,7 @@ gimplify_init_ctor_eval (tree object, VE
gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
pre_p, cleared);
else
- gimple_add (pre_p, gimple_build_assign (cref, value));
+ gimple_add (pre_p, build_gimple_assign (cref, value));
}
}
@@ -3728,7 +3728,7 @@ gimplify_modify_expr_complex_part (tree
if (want_value)
*expr_p = rhs;
- gimple_add (pre_p, gimple_build_assign (lhs, new_rhs));
+ gimple_add (pre_p, build_gimple_assign (lhs, new_rhs));
return GS_ALL_DONE;
}
@@ -3845,7 +3845,7 @@ gimplify_modify_expr (tree *expr_p, gimp
SET_DECL_DEBUG_EXPR (*from_p, *to_p);
}
- gimple_add (pre_p, gimple_build_assign (*to_p, *from_p));
+ gimple_add (pre_p, build_gimple_assign (*to_p, *from_p));
if (want_value)
{
@@ -4415,8 +4415,8 @@ gimple_push_cleanup (tree var, tree clea
#if 0 /* FIXME tuples */
/* FIXME tuples */
tree flag = create_tmp_var (boolean_type_node, "cleanup");
- gimple ffalse = gimple_build_assign (flag, boolean_false_node);
- gimple ftrue = gimple_build_assign (flag, boolean_true_node);
+ gimple ffalse = build_gimple_assign (flag, boolean_false_node);
+ gimple ftrue = build_gimple_assign (flag, boolean_true_node);
cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
gimple_add (&gimplify_ctxp->conditional_cleanups, ffalse);
@@ -5954,14 +5954,14 @@ gimplify_expr (tree *expr_p, gimple_seq
if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
NULL, is_gimple_val, fb_rvalue);
- gimple_add (pre_p, gimple_build_goto (GOTO_DESTINATION (*expr_p)));
+ gimple_add (pre_p, build_gimple_goto (GOTO_DESTINATION (*expr_p)));
break;
case LABEL_EXPR:
ret = GS_ALL_DONE;
gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
== current_function_decl);
- gimple_add (pre_p, gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
+ gimple_add (pre_p, build_gimple_label (LABEL_EXPR_LABEL (*expr_p)));
break;
case CASE_LABEL_EXPR:
@@ -6041,7 +6041,7 @@ gimplify_expr (tree *expr_p, gimple_seq
case TRY_CATCH_EXPR:
{
gimple try
- = gimple_build_try (NULL, NULL,
+ = build_gimple_try (NULL, NULL,
TREE_CODE (*expr_p) == TRY_FINALLY_EXPR ?
GIMPLE_TRY_FINALLY : GIMPLE_TRY_CATCH);
@@ -6722,14 +6722,14 @@ gimplify_body (tree *body_p, gimple_seq
outer_bind = gimple_seq_first (seq_p);
if (!outer_bind)
{
- outer_bind = gimple_build_nop ();
+ outer_bind = build_gimple_nop ();
gimple_add (seq_p, outer_bind);
}
/* If there isn't an outer GIMPLE_BIND, add one. */
if (GIMPLE_CODE (outer_bind) != GIMPLE_BIND)
{
- outer_bind = gimple_build_bind (NULL_TREE, seq_p);
+ outer_bind = build_gimple_bind (NULL_TREE, seq_p);
gimple_add (seq_p, outer_bind);
}
@@ -6803,13 +6803,13 @@ gimplify_function_tree (tree fndecl)
tree x;
gimple tf, bind;
- tf = gimple_build_try (seq, NULL, GIMPLE_TRY_FINALLY);
+ tf = build_gimple_try (seq, NULL, GIMPLE_TRY_FINALLY);
x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
- gimple_add (gimple_try_cleanup (tf), gimple_build_call (x, 0));
+ gimple_add (gimple_try_cleanup (tf), build_gimple_call (x, 0));
- bind = gimple_build_bind (NULL, NULL);
+ bind = build_gimple_bind (NULL, NULL);
x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
- gimple_add (gimple_bind_body (bind), gimple_build_call (x, 0));
+ gimple_add (gimple_bind_body (bind), build_gimple_call (x, 0));
gimple_add (gimple_bind_body (bind), tf);
gimple_seq_init (seq);
Index: gimple.c
===================================================================
--- gimple.c (revision 126917)
+++ gimple.c (working copy)
@@ -89,7 +89,7 @@ gss_for_code (enum gimple_code code)
for the new tuple. NUM_OPS is the number of operands to allocate. */
static gimple
-gimple_build_with_ops (enum gimple_code code, unsigned subcode, size_t num_ops)
+build_gimple_with_ops (enum gimple_code code, unsigned subcode, size_t num_ops)
{
gimple s;
enum gimple_statement_structure_enum gss = gss_for_code (code);
@@ -116,21 +116,21 @@ gimple_build_with_ops (enum gimple_code
RETVAL is the return value. */
gimple
-gimple_build_return (bool result_decl_p, tree retval)
+build_gimple_return (bool result_decl_p, tree retval)
{
- gimple s = gimple_build_with_ops (GIMPLE_RETURN, (int) result_decl_p, 1);
+ gimple s = build_gimple_with_ops (GIMPLE_RETURN, (int) result_decl_p, 1);
gimple_return_set_retval (s, retval);
return s;
}
-/* Helper for gimple_build_call and gimple_build_call_vec. Build the basic
+/* Helper for build_gimple_call and build_gimple_call_vec. Build the basic
components of a GIMPLE_CALL statement to function FN with NARGS
arguments. */
static inline gimple
-gimple_build_call_1 (tree fn, size_t nargs)
+build_gimple_call_1 (tree fn, size_t nargs)
{
- gimple s = gimple_build_with_ops (GIMPLE_CALL, 0, nargs + 3);
+ gimple s = build_gimple_with_ops (GIMPLE_CALL, 0, nargs + 3);
s->with_ops.op[1] = fn;
return s;
}
@@ -140,11 +140,11 @@ gimple_build_call_1 (tree fn, size_t nar
specified in vector ARGS. */
gimple
-gimple_build_call_vec (tree fn, VEC(tree, gc) *args)
+build_gimple_call_vec (tree fn, VEC(tree, gc) *args)
{
size_t i;
size_t nargs = VEC_length (tree, args);
- gimple call = gimple_build_call_1 (fn, nargs);
+ gimple call = build_gimple_call_1 (fn, nargs);
for (i = 0; i < nargs; i++)
gimple_call_set_arg (call, i, VEC_index (tree, args, i));
@@ -157,13 +157,13 @@ gimple_build_call_vec (tree fn, VEC(tree
arguments. The ... are the arguments. */
gimple
-gimple_build_call (tree fn, size_t nargs, ...)
+build_gimple_call (tree fn, size_t nargs, ...)
{
va_list ap;
gimple call;
size_t i;
- call = gimple_build_call_1 (fn, nargs);
+ call = build_gimple_call_1 (fn, nargs);
va_start (ap, nargs);
for (i = 0; i < nargs; i++)
@@ -190,7 +190,7 @@ get_num_ops_for (enum tree_code code)
RHS of the assignment which can be unary or binary. */
gimple
-gimple_build_assign (tree lhs, tree rhs)
+build_gimple_assign (tree lhs, tree rhs)
{
gimple p;
size_t num_ops;
@@ -204,7 +204,7 @@ gimple_build_assign (tree lhs, tree rhs)
code). */
num_ops = get_num_ops_for (subcode) + 1;
- p = gimple_build_with_ops (GIMPLE_ASSIGN, subcode, num_ops);
+ p = build_gimple_with_ops (GIMPLE_ASSIGN, subcode, num_ops);
gimple_assign_set_lhs (p, lhs);
if (class == tcc_binary || class == tcc_comparison)
@@ -232,10 +232,10 @@ gimple_build_assign (tree lhs, tree rhs)
F_LABEL is teh label to jump to otherwise. */
gimple
-gimple_build_cond (enum gimple_cond pred, tree lhs, tree rhs,
+build_gimple_cond (enum gimple_cond pred, tree lhs, tree rhs,
tree t_label, tree f_label)
{
- gimple p = gimple_build_with_ops (GIMPLE_COND, pred, 4);
+ gimple p = build_gimple_with_ops (GIMPLE_COND, pred, 4);
gimple_cond_set_lhs (p, lhs);
gimple_cond_set_rhs (p, rhs);
gimple_cond_set_true_label (p, t_label);
@@ -258,9 +258,9 @@ gimple_cond_invert (gimple g)
/* Construct a GIMPLE_LABEL statement for LABEL. */
gimple
-gimple_build_label (tree label)
+build_gimple_label (tree label)
{
- gimple p = gimple_build_with_ops (GIMPLE_LABEL, 0, 1);
+ gimple p = build_gimple_with_ops (GIMPLE_LABEL, 0, 1);
gimple_label_set_label (p, label);
return p;
}
@@ -268,9 +268,9 @@ gimple_build_label (tree label)
/* Construct a GIMPLE_GOTO statement to DEST. */
gimple
-gimple_build_goto (tree dest)
+build_gimple_goto (tree dest)
{
- gimple p = gimple_build_with_ops (GIMPLE_GOTO, 0, 1);
+ gimple p = build_gimple_with_ops (GIMPLE_GOTO, 0, 1);
gimple_goto_set_dest (p, dest);
return p;
}
@@ -278,7 +278,7 @@ gimple_build_goto (tree dest)
/* Construct a GIMPLE_NOP statement. */
gimple
-gimple_build_nop (void)
+build_gimple_nop (void)
{
gimple p = ggc_alloc_cleared (sizeof (struct gimple_statement_base));
GIMPLE_CODE (p) = GIMPLE_NOP;
@@ -290,7 +290,7 @@ gimple_build_nop (void)
VARS are the variables in BODY. */
gimple
-gimple_build_bind (tree vars, gimple_seq body)
+build_gimple_bind (tree vars, gimple_seq body)
{
gimple p = ggc_alloc_cleared (sizeof (struct gimple_statement_bind));
GIMPLE_CODE (p) = GIMPLE_BIND;
@@ -309,7 +309,7 @@ gimple_build_bind (tree vars, gimple_seq
... are trees for each input, output and clobbered register. */
gimple
-gimple_build_asm (const char *string, unsigned ninputs, unsigned noutputs,
+build_gimple_asm (const char *string, unsigned ninputs, unsigned noutputs,
unsigned nclobbers, ...)
{
gimple p;
@@ -346,7 +346,7 @@ gimple_build_asm (const char *string, un
HANDLER is the exception handler. */
gimple
-gimple_build_catch (tree types, gimple_seq handler)
+build_gimple_catch (tree types, gimple_seq handler)
{
gimple p;
@@ -365,7 +365,7 @@ gimple_build_catch (tree types, gimple_s
FAILURE is the filter's failure action. */
gimple
-gimple_build_eh_filter (tree types, gimple_seq failure)
+build_gimple_eh_filter (tree types, gimple_seq failure)
{
gimple p;
@@ -386,7 +386,7 @@ gimple_build_eh_filter (tree types, gimp
whether this is a try/catch or a try/finally respectively. */
gimple
-gimple_build_try (gimple_seq eval, gimple_seq cleanup,
+build_gimple_try (gimple_seq eval, gimple_seq cleanup,
unsigned int catch_finally)
{
gimple p;
@@ -413,7 +413,7 @@ gimple_build_try (gimple_seq eval, gimpl
... phi_arg_d* for the incomming edges to this node. */
gimple
-gimple_build_phi (unsigned capacity, unsigned nargs, tree result, ...)
+build_gimple_phi (unsigned capacity, unsigned nargs, tree result, ...)
{
gimple p;
unsigned int i;
@@ -443,7 +443,7 @@ gimple_build_phi (unsigned capacity, uns
leave. */
gimple
-gimple_build_resx (int region)
+build_gimple_resx (int region)
{
gimple p;
@@ -460,10 +460,10 @@ gimple_build_resx (int region)
DEFAULT_LABEL is the default label for the switch statement. */
static inline gimple
-gimple_build_switch_1 (unsigned int nlabels, tree index, tree default_label)
+build_gimple_switch_1 (unsigned int nlabels, tree index, tree default_label)
{
/* nlabels + 1 default label + 1 index. */
- gimple p = gimple_build_with_ops (GIMPLE_SWITCH, 0, nlabels + 1 + 1);
+ gimple p = build_gimple_with_ops (GIMPLE_SWITCH, 0, nlabels + 1 + 1);
gimple_switch_set_index (p, index);
gimple_switch_set_default_label (p, default_label);
return p;
@@ -477,13 +477,13 @@ gimple_build_switch_1 (unsigned int nlab
... are the labels excluding the default. */
gimple
-gimple_build_switch (unsigned int nlabels, tree index, tree default_label, ...)
+build_gimple_switch (unsigned int nlabels, tree index, tree default_label, ...)
{
va_list al;
unsigned int i;
gimple p;
- p = gimple_build_switch_1 (nlabels, index, default_label);
+ p = build_gimple_switch_1 (nlabels, index, default_label);
/* Store the rest of the labels. */
va_start (al, default_label);
@@ -502,11 +502,11 @@ gimple_build_switch (unsigned int nlabel
ARGS is a vector of labels excluding the default. */
gimple
-gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
+build_gimple_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
{
size_t i;
size_t nlabels = VEC_length (tree, args);
- gimple p = gimple_build_switch_1 (nlabels, index, default_label);
+ gimple p = build_gimple_switch_1 (nlabels, index, default_label);
/* Put labels in labels[1 - (nlabels + 1)].
Default label is in labels[0]. */
@@ -523,7 +523,7 @@ gimple_build_switch_vec (tree index, tre
NAME is optional identifier for this critical block. */
gimple
-gimple_omp_build_critical (gimple_seq body, tree name)
+build_gimple_omp_critical (gimple_seq body, tree name)
{
gimple p;
@@ -549,7 +549,7 @@ gimple_omp_build_critical (gimple_seq bo
INCR is the increment expression. */
gimple
-gimple_omp_build_for (gimple_seq body, tree clauses, tree index,
+build_gimple_omp_for (gimple_seq body, tree clauses, tree index,
tree initial, tree final, tree incr,
gimple_seq pre_body, enum gimple_cond omp_for_cond)
{
@@ -579,7 +579,7 @@ gimple_omp_build_for (gimple_seq body, t
DATA_ARG are the shared data argument(s). */
gimple
-gimple_omp_build_parallel (gimple_seq body, tree clauses, tree child_fn,
+build_gimple_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
tree data_arg)
{
gimple p;
@@ -600,7 +600,7 @@ gimple_omp_build_parallel (gimple_seq bo
BODY is the sequence of statements in the section. */
gimple
-gimple_omp_build_section (gimple_seq body)
+build_gimple_omp_section (gimple_seq body)
{
gimple p;
@@ -616,7 +616,7 @@ gimple_omp_build_section (gimple_seq bod
BODY is the sequence of statements to be executed by just the master. */
gimple
-gimple_omp_build_master (gimple_seq body)
+build_gimple_omp_master (gimple_seq body)
{
gimple p;
@@ -631,7 +631,7 @@ gimple_omp_build_master (gimple_seq body
FIXME tuples: BODY. */
gimple
-gimple_omp_build_continue (gimple_seq body)
+build_gimple_omp_continue (gimple_seq body)
{
gimple p;
@@ -649,7 +649,7 @@ gimple_omp_build_continue (gimple_seq bo
sequence. */
gimple
-gimple_omp_build_ordered (gimple_seq body)
+build_gimple_omp_ordered (gimple_seq body)
{
gimple p;
@@ -665,7 +665,7 @@ gimple_omp_build_ordered (gimple_seq bod
WAIT_P is true if this is a non-waiting return. */
gimple
-gimple_omp_build_return (bool wait_p)
+build_gimple_omp_return (bool wait_p)
{
gimple p;
@@ -684,7 +684,7 @@ gimple_omp_build_return (bool wait_p)
firstprivate, lastprivate, reduction, and nowait. */
gimple
-gimple_omp_build_sections (gimple_seq body, tree clauses)
+build_gimple_omp_sections (gimple_seq body, tree clauses)
{
gimple p;
@@ -704,7 +704,7 @@ gimple_omp_build_sections (gimple_seq bo
copyprivate, nowait. */
gimple
-gimple_omp_build_single (gimple_seq body, tree clauses)
+build_gimple_omp_single (gimple_seq body, tree clauses)
{
gimple p;
Index: gimple.h
===================================================================
--- gimple.h (revision 126917)
+++ gimple.h (working copy)
@@ -313,36 +313,36 @@ union gimple_statement_d GTY ((desc ("gi
/* In gimple.c. */
-extern gimple gimple_build_return (bool, tree);
-extern gimple gimple_build_assign (tree, tree);
-extern gimple gimple_build_call_vec (tree, VEC(tree, gc) *);
-extern gimple gimple_build_call (tree, size_t, ...);
-extern gimple gimple_build_cond (enum gimple_cond, tree, tree, tree, tree);
+extern gimple build_gimple_return (bool, tree);
+extern gimple build_gimple_assign (tree, tree);
+extern gimple build_gimple_call_vec (tree, VEC(tree, gc) *);
+extern gimple build_gimple_call (tree, size_t, ...);
+extern gimple build_gimple_cond (enum gimple_cond, tree, tree, tree, tree);
extern void gimple_cond_invert (gimple);
-extern gimple gimple_build_label (tree label);
-extern gimple gimple_build_goto (tree dest);
-extern gimple gimple_build_nop (void);
-extern gimple gimple_build_bind (tree, gimple_seq);
-extern gimple gimple_build_asm (const char *, unsigned, unsigned, unsigned,
+extern gimple build_gimple_label (tree label);
+extern gimple build_gimple_goto (tree dest);
+extern gimple build_gimple_nop (void);
+extern gimple build_gimple_bind (tree, gimple_seq);
+extern gimple build_gimple_asm (const char *, unsigned, unsigned, unsigned,
...);
-extern gimple gimple_build_catch (tree, gimple_seq);
-extern gimple gimple_build_eh_filter (tree, gimple_seq);
-extern gimple gimple_build_try (gimple_seq, gimple_seq, unsigned int);
-extern gimple gimple_build_phi (unsigned, unsigned, tree, ...);
-extern gimple gimple_build_resx (int);
-extern gimple gimple_build_switch (unsigned int, tree, tree, ...);
-extern gimple gimple_build_switch_vec (tree, tree, VEC(tree,heap) *);
-extern gimple gimple_omp_build_parallel (gimple_seq, tree, tree, tree);
-extern gimple gimple_omp_build_for (gimple_seq, tree, tree, tree, tree, tree,
+extern gimple build_gimple_catch (tree, gimple_seq);
+extern gimple build_gimple_eh_filter (tree, gimple_seq);
+extern gimple build_gimple_try (gimple_seq, gimple_seq, unsigned int);
+extern gimple build_gimple_phi (unsigned, unsigned, tree, ...);
+extern gimple build_gimple_resx (int);
+extern gimple build_gimple_switch (unsigned int, tree, tree, ...);
+extern gimple build_gimple_switch_vec (tree, tree, VEC(tree,heap) *);
+extern gimple build_gimple_omp_parallel (gimple_seq, tree, tree, tree);
+extern gimple build_gimple_omp_for (gimple_seq, tree, tree, tree, tree, tree,
gimple_seq, enum gimple_cond);
-extern gimple gimple_omp_build_critical (gimple_seq, tree);
-extern gimple gimple_omp_build_section (gimple_seq);
-extern gimple gimple_omp_build_continue (gimple_seq);
-extern gimple gimple_omp_build_master (gimple_seq);
-extern gimple gimple_omp_build_return (bool);
-extern gimple gimple_omp_build_ordered (gimple_seq);
-extern gimple gimple_omp_build_sections (gimple_seq, tree);
-extern gimple gimple_omp_build_single (gimple_seq, tree);
+extern gimple build_gimple_omp_critical (gimple_seq, tree);
+extern gimple build_gimple_omp_section (gimple_seq);
+extern gimple build_gimple_omp_continue (gimple_seq);
+extern gimple build_gimple_omp_master (gimple_seq);
+extern gimple build_gimple_omp_return (bool);
+extern gimple build_gimple_omp_ordered (gimple_seq);
+extern gimple build_gimple_omp_sections (gimple_seq, tree);
+extern gimple build_gimple_omp_single (gimple_seq, tree);
extern enum gimple_statement_structure_enum gimple_statement_structure (gimple);
extern void gimple_add (gimple_seq, gimple);
extern enum gimple_statement_structure_enum gss_for_assign (enum tree_code);