[tuples] Rename gimple_build_* to build_gimple_*

[tuples] Rename gimple_build_* to build_gimple_*

[Diego Novillo]

[-- Attachment #1: Type: text/plain, Size: 71 bytes --]


Picky, picky, picky.

No functional changes, just the names reversed.

[-- Attachment #2: 20070725-rename-gimple_build.diff --]
[-- Type: text/x-patch, Size: 29023 bytes --]

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);