* tree-core.h (tree_code_name): Remove.
* tree.h (get_tree_code_name): New prototype.
* tree.c (tree_code_name): Make static.
(get_tree_code_name): New function.
(dump_tree_statistics, tree_check_failed, tree_not_check_failed,
tree_class_check_failed, tree_range_check_failed,
tree_not_class_check_failed, omp_clause_check_failed,
tree_contains_struct_check_failed, tree_operand_check_failed): Use new
wrapper get_tree_code_name instead of calling tree_code_name directly.
* tree-vrp.c (dump_asserts_for): Likewise.
* tree-dump.c (dequeue_and_dump): Likewise.
* tree-pretty-print.c (do_niy, dump_generic_node): Likewise.
* tree-pretty-print.h (pp_unsupported_tree): Likewise.
* lto-streamer-out.c (lto_write_tree, DFS_write_tree): Likewise.
* tree-ssa-dom.c (print_expr_hash_elt): Likewise.
* gimple-pretty-print.c (dump_unary_rhs, dump_binary_rhs,
dump_ternary_rhs, dump_gimple_assign, dump_gimple_cond,
dump_gimple_omp_for): Likewise.
* tree-vect-data-refs.c (vect_create_data_ref_ptr): Likewise.
* tree-ssa-pre.c (print_pre_expr): Likewise.
* ipa-prop.c (ipa_print_node_jump_functions_for_edge): Likewise.
* print-tree.c (print_node_brief, print_node): Likewise.
* gimple.c (gimple_check_failed): Likewise.
* lto-streamer.c (lto_tag_name, print_lto_report): Likewise.
* config/frv/frv.c (frv_init_cumulative_args): Likewise.
* config/mep/mep.c (mep_validate_vliw): Likewise.
* config/iq2000/iq2000.c (init_cumulative_args): Likewise.
* config/rs6000/rs6000.c (init_cumulative_args): Likewise.
gcc/cp/
* error.c (code_to_string): Use new wrapper get_tree_code_name.
* cxx-pretty-print.c (pp_cxx_assignment_operator): Likewise.
* pt.c (tsubst): Likewise.
* semantics.c (cxx_eval_constant_expression,
potential_constant_expression_1): Likewise.
* mangle.c (MANGLE_TRACE_TREE, dump_substitution_candidates,
add_substitution, find_substitution): Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@203695
138bc75d-0d04-0410-961f-
82ee72b054a4
+2013-10-16 Paulo Matos <pmatos@broadcom.com>
+
+ * tree-core.h (tree_code_name): Remove.
+ * tree.h (get_tree_code_name): New prototype.
+ * tree.c (tree_code_name): Make static.
+ (get_tree_code_name): New function.
+ (dump_tree_statistics, tree_check_failed, tree_not_check_failed,
+ tree_class_check_failed, tree_range_check_failed,
+ tree_not_class_check_failed, omp_clause_check_failed,
+ tree_contains_struct_check_failed, tree_operand_check_failed): Use new
+ wrapper get_tree_code_name instead of calling tree_code_name directly.
+ * tree-vrp.c (dump_asserts_for): Likewise.
+ * tree-dump.c (dequeue_and_dump): Likewise.
+ * tree-pretty-print.c (do_niy, dump_generic_node): Likewise.
+ * tree-pretty-print.h (pp_unsupported_tree): Likewise.
+ * lto-streamer-out.c (lto_write_tree, DFS_write_tree): Likewise.
+ * tree-ssa-dom.c (print_expr_hash_elt): Likewise.
+ * gimple-pretty-print.c (dump_unary_rhs, dump_binary_rhs,
+ dump_ternary_rhs, dump_gimple_assign, dump_gimple_cond,
+ dump_gimple_omp_for): Likewise.
+ * tree-vect-data-refs.c (vect_create_data_ref_ptr): Likewise.
+ * tree-ssa-pre.c (print_pre_expr): Likewise.
+ * ipa-prop.c (ipa_print_node_jump_functions_for_edge): Likewise.
+ * print-tree.c (print_node_brief, print_node): Likewise.
+ * gimple.c (gimple_check_failed): Likewise.
+ * lto-streamer.c (lto_tag_name, print_lto_report): Likewise.
+ * config/frv/frv.c (frv_init_cumulative_args): Likewise.
+ * config/mep/mep.c (mep_validate_vliw): Likewise.
+ * config/iq2000/iq2000.c (init_cumulative_args): Likewise.
+ * config/rs6000/rs6000.c (init_cumulative_args): Likewise.
+
2013-10-16 Ganesh Gopalasubramanian <Ganesh.Gopalasubramanian@amd.com>
* config/i386/i386.c (ix86_option_override_internal): Enable FMA4
{
tree ret_type = TREE_TYPE (fntype);
fprintf (stderr, " return=%s,",
- tree_code_name[ (int)TREE_CODE (ret_type) ]);
+ get_tree_code_name ((int)TREE_CODE (ret_type)));
}
if (libname && GET_CODE (libname) == SYMBOL_REF)
tree ret_type = TREE_TYPE (fntype);
fprintf (stderr, ", fntype code = %s, ret code = %s\n",
- tree_code_name[(int)TREE_CODE (fntype)],
- tree_code_name[(int)TREE_CODE (ret_type)]);
+ get_tree_code_name (TREE_CODE (fntype)),
+ get_tree_code_name (TREE_CODE (ret_type)));
}
}
static int gave_array_note = 0;
static const char * given_type = NULL;
- given_type = tree_code_name[TREE_CODE (*node)];
+ given_type = get_tree_code_name (TREE_CODE (*node));
if (TREE_CODE (*node) == POINTER_TYPE)
given_type = "pointers";
if (TREE_CODE (*node) == ARRAY_TYPE)
{
tree ret_type = TREE_TYPE (fntype);
fprintf (stderr, " ret code = %s,",
- tree_code_name[ (int)TREE_CODE (ret_type) ]);
+ get_tree_code_name (TREE_CODE (ret_type)));
}
if (cum->call_cookie & CALL_LONG)
+2013-10-16 Paulo Matos <pmatos@broadcom.com>
+
+ * error.c (code_to_string): Use new wrapper get_tree_code_name.
+ * cxx-pretty-print.c (pp_cxx_assignment_operator): Likewise.
+ * pt.c (tsubst): Likewise.
+ * semantics.c (cxx_eval_constant_expression,
+ potential_constant_expression_1): Likewise.
+ * mangle.c (MANGLE_TRACE_TREE, dump_substitution_candidates,
+ add_substitution, find_substitution): Likewise.
+
2013-10-15 Paolo Carlini <paolo.carlini@oracle.com>
PR c++/58707
break;
default:
- op = tree_code_name[TREE_CODE (t)];
+ op = get_tree_code_name (TREE_CODE (t));
break;
}
static const char *
code_to_string (enum tree_code c)
{
- return tree_code_name [c];
+ return get_tree_code_name (c);
}
const char *
fprintf (stderr, " %-24s: %-24s\n", (FN), (INPUT))
# define MANGLE_TRACE_TREE(FN, NODE) \
fprintf (stderr, " %-24s: %-24s (%p)\n", \
- (FN), tree_code_name[TREE_CODE (NODE)], (void *) (NODE))
+ (FN), get_tree_code_name (TREE_CODE (NODE)), (void *) (NODE))
#else
# define MANGLE_TRACE(FN, INPUT)
# define MANGLE_TRACE_TREE(FN, NODE)
|| CP_TYPE_CONST_P (el)))
fprintf (stderr, "CV-");
fprintf (stderr, "%s (%s at %p)\n",
- name, tree_code_name[TREE_CODE (el)], (void *) el);
+ name, get_tree_code_name (TREE_CODE (el)), (void *) el);
}
}
if (DEBUG_MANGLE)
fprintf (stderr, " ++ add_substitution (%s at %10p)\n",
- tree_code_name[TREE_CODE (node)], (void *) node);
+ get_tree_code_name (TREE_CODE (node)), (void *) node);
/* Get the canonicalized substitution candidate for NODE. */
c = canonicalize_for_substitution (node);
if (DEBUG_MANGLE && c != node)
fprintf (stderr, " ++ using candidate (%s at %10p)\n",
- tree_code_name[TREE_CODE (node)], (void *) node);
+ get_tree_code_name (TREE_CODE (node)), (void *) node);
node = c;
#if ENABLE_CHECKING
if (DEBUG_MANGLE)
fprintf (stderr, " ++ find_substitution (%s at %p)\n",
- tree_code_name[TREE_CODE (node)], (void *) node);
+ get_tree_code_name (TREE_CODE (node)), (void *) node);
/* Obtain the canonicalized substitution representation for NODE.
This is what we'll compare against. */
gcc_unreachable ();
default:
- sorry ("use of %qs in template", tree_code_name [(int) code]);
+ sorry ("use of %qs in template", get_tree_code_name ((int) code));
return error_mark_node;
}
}
default:
internal_error ("unexpected expression %qE of kind %s", t,
- tree_code_name[TREE_CODE (t)]);
+ get_tree_code_name (TREE_CODE (t)));
*non_constant_p = true;
break;
}
if (objc_is_property_ref (t))
return false;
- sorry ("unexpected AST of kind %s", tree_code_name[TREE_CODE (t)]);
+ sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
gcc_unreachable();
return false;
}
else
{
pp_left_bracket (buffer);
- pp_string (buffer, tree_code_name [rhs_code]);
+ pp_string (buffer, get_tree_code_name (rhs_code));
pp_string (buffer, "] ");
}
case VEC_PACK_FIX_TRUNC_EXPR:
case VEC_WIDEN_LSHIFT_HI_EXPR:
case VEC_WIDEN_LSHIFT_LO_EXPR:
- for (p = tree_code_name [(int) code]; *p; p++)
+ for (p = get_tree_code_name (code); *p; p++)
pp_character (buffer, TOUPPER (*p));
pp_string (buffer, " <");
dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
{
case WIDEN_MULT_PLUS_EXPR:
case WIDEN_MULT_MINUS_EXPR:
- for (p = tree_code_name [(int) code]; *p; p++)
+ for (p = get_tree_code_name (code); *p; p++)
pp_character (buffer, TOUPPER (*p));
pp_string (buffer, " <");
dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
}
dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
- tree_code_name[gimple_assign_rhs_code (gs)],
+ get_tree_code_name (gimple_assign_rhs_code (gs)),
gimple_assign_lhs (gs), arg1, arg2, arg3);
}
else
{
if (flags & TDF_RAW)
dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs,
- tree_code_name [gimple_cond_code (gs)],
- gimple_cond_lhs (gs), gimple_cond_rhs (gs),
- gimple_cond_true_label (gs), gimple_cond_false_label (gs));
+ get_tree_code_name (gimple_cond_code (gs)),
+ gimple_cond_lhs (gs), gimple_cond_rhs (gs),
+ gimple_cond_true_label (gs), gimple_cond_false_label (gs));
else
{
if (!(flags & TDF_RHS_ONLY))
gimple_omp_for_index (gs, i),
gimple_omp_for_initial (gs, i),
gimple_omp_for_final (gs, i),
- tree_code_name[gimple_omp_for_cond (gs, i)],
+ get_tree_code_name (gimple_omp_for_cond (gs, i)),
gimple_omp_for_incr (gs, i));
dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->",
gimple_omp_for_pre_body (gs));
{
internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
gimple_code_name[code],
- tree_code_name[subcode],
+ get_tree_code_name (subcode),
gimple_code_name[gimple_code (gs)],
gs->gsbase.subcode > 0
- ? tree_code_name[gs->gsbase.subcode]
+ ? get_tree_code_name ((enum tree_code) gs->gsbase.subcode)
: "",
function, trim_filename (file), line);
}
fprintf (f, "PASS THROUGH: ");
fprintf (f, "%d, op %s",
jump_func->value.pass_through.formal_id,
- tree_code_name[(int)
- jump_func->value.pass_through.operation]);
+ get_tree_code_name(jump_func->value.pass_through.operation));
if (jump_func->value.pass_through.operation != NOP_EXPR)
{
fprintf (f, " ");
{
if (!lto_is_streamable (expr))
internal_error ("tree code %qs is not supported in LTO streams",
- tree_code_name[TREE_CODE (expr)]);
+ get_tree_code_name (TREE_CODE (expr)));
/* Write the header, containing everything needed to materialize
EXPR on the reading side. */
if (!lto_is_streamable (t))
internal_error ("tree code %qs is not supported "
"in LTO streams",
- tree_code_name[TREE_CODE (t)]);
+ get_tree_code_name (TREE_CODE (t)));
gcc_checking_assert (!streamer_handle_as_builtin_p (t));
{
/* For tags representing tree nodes, return the name of the
associated tree code. */
- return tree_code_name[lto_tag_to_tree_code (tag)];
+ return get_tree_code_name (lto_tag_to_tree_code (tag));
}
if (lto_tag_is_gimple_code_p (tag))
if (lto_stats.num_trees[i])
fprintf (stderr, "[%s] # of '%s' objects read: "
HOST_WIDE_INT_PRINT_UNSIGNED "\n", s,
- tree_code_name[i], lto_stats.num_trees[i]);
+ get_tree_code_name ((enum tree_code) i), lto_stats.num_trees[i]);
if (flag_lto)
{
name if any. */
if (indent > 0)
fprintf (file, " ");
- fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
+ fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
dump_addr (file, " ", node);
if (tclass == tcc_declaration)
indent_to (file, indent);
/* Print the slot this node is in, and its code, and address. */
- fprintf (file, "%s <%s", prefix, tree_code_name[(int) code]);
+ fprintf (file, "%s <%s", prefix, get_tree_code_name (code));
dump_addr (file, " ", node);
/* Print the name, if any. */
/* Number of argument-words in each kind of tree-node. */
extern const unsigned char tree_code_length[];
-/* Names of tree components. */
-extern const char *const tree_code_name[];
-
/* Vector of all alias pairs for global symbols. */
extern GTY(()) vec<alias_pair, va_gc> *alias_pairs;
if (dni->binfo_p)
code_name = "binfo";
else
- code_name = tree_code_name[(int) TREE_CODE (t)];
+ code_name = get_tree_code_name (TREE_CODE (t));
fprintf (di->stream, "%-16s ", code_name);
di->column = 25;
int i, len;
pp_string (buffer, "<<< Unknown tree: ");
- pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);
+ pp_string (buffer, get_tree_code_name (TREE_CODE (node)));
if (EXPR_P (node))
{
case VEC_WIDEN_LSHIFT_HI_EXPR:
case VEC_WIDEN_LSHIFT_LO_EXPR:
pp_space (buffer);
- for (str = tree_code_name [code]; *str; str++)
+ for (str = get_tree_code_name (code); *str; str++)
pp_character (buffer, TOUPPER (*str));
pp_string (buffer, " < ");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
#define pp_unsupported_tree(PP, T) \
pp_verbatim (PP, "#%qs not supported by %s#", \
- tree_code_name[(int) TREE_CODE (T)], __FUNCTION__)
+ get_tree_code_name (TREE_CODE (T)), __FUNCTION__)
#define pp_ti_abstract_origin(TI) ((tree *) (TI)->x_data)
break;
case EXPR_UNARY:
- fprintf (stream, "%s ", tree_code_name[element->expr.ops.unary.op]);
+ fprintf (stream, "%s ", get_tree_code_name (element->expr.ops.unary.op));
print_generic_expr (stream, element->expr.ops.unary.opnd, 0);
break;
case EXPR_BINARY:
print_generic_expr (stream, element->expr.ops.binary.opnd0, 0);
- fprintf (stream, " %s ", tree_code_name[element->expr.ops.binary.op]);
+ fprintf (stream, " %s ", get_tree_code_name (element->expr.ops.binary.op));
print_generic_expr (stream, element->expr.ops.binary.opnd1, 0);
break;
case EXPR_TERNARY:
- fprintf (stream, " %s <", tree_code_name[element->expr.ops.ternary.op]);
+ fprintf (stream, " %s <", get_tree_code_name (element->expr.ops.ternary.op));
print_generic_expr (stream, element->expr.ops.ternary.opnd0, 0);
fputs (", ", stream);
print_generic_expr (stream, element->expr.ops.ternary.opnd1, 0);
{
unsigned int i;
vn_nary_op_t nary = PRE_EXPR_NARY (expr);
- fprintf (outfile, "{%s,", tree_code_name [nary->opcode]);
+ fprintf (outfile, "{%s,", get_tree_code_name (nary->opcode));
for (i = 0; i < nary->length; i++)
{
print_generic_expr (outfile, nary->op[i], 0);
if (vro->opcode != SSA_NAME
&& TREE_CODE_CLASS (vro->opcode) != tcc_declaration)
{
- fprintf (outfile, "%s", tree_code_name [vro->opcode]);
+ fprintf (outfile, "%s", get_tree_code_name (vro->opcode));
if (vro->op0)
{
fprintf (outfile, "<");
tree dr_base_type = TREE_TYPE (DR_BASE_OBJECT (dr));
dump_printf_loc (MSG_NOTE, vect_location,
"create %s-pointer variable to type: ",
- tree_code_name[(int) TREE_CODE (aggr_type)]);
+ get_tree_code_name (TREE_CODE (aggr_type)));
dump_generic_expr (MSG_NOTE, TDF_SLIM, aggr_type);
if (TREE_CODE (dr_base_type) == ARRAY_TYPE)
dump_printf (MSG_NOTE, " vectorizing an array ref: ");
}
fprintf (file, "\n\tPREDICATE: ");
print_generic_expr (file, name, 0);
- fprintf (file, " %s ", tree_code_name[(int)loc->comp_code]);
+ fprintf (file, " %s ", get_tree_code_name (loc->comp_code));
print_generic_expr (file, loc->val, 0);
fprintf (file, "\n\n");
loc = loc->next;
#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
#define END_OF_BASE_TREE_CODES "@dummy",
-const char *const tree_code_name[] = {
+static const char *const tree_code_name[] = {
#include "all-tree.def"
};
fprintf (stderr, "Code Nodes\n");
fprintf (stderr, "----------------------------\n");
for (i = 0; i < (int) MAX_TREE_CODES; i++)
- fprintf (stderr, "%-20s %7d\n", tree_code_name[i], tree_code_counts[i]);
+ fprintf (stderr, "%-20s %7d\n", get_tree_code_name ((enum tree_code) i),
+ tree_code_counts[i]);
fprintf (stderr, "----------------------------\n");
ssanames_print_statistics ();
phinodes_print_statistics ();
va_list args;
const char *buffer;
unsigned length = 0;
- int code;
+ enum tree_code code;
va_start (args, function);
- while ((code = va_arg (args, int)))
- length += 4 + strlen (tree_code_name[code]);
+ while ((code = (enum tree_code) va_arg (args, int)))
+ length += 4 + strlen (get_tree_code_name (code));
va_end (args);
if (length)
{
length += strlen ("expected ");
buffer = tmp = (char *) alloca (length);
length = 0;
- while ((code = va_arg (args, int)))
+ while ((code = (enum tree_code) va_arg (args, int)))
{
const char *prefix = length ? " or " : "expected ";
strcpy (tmp + length, prefix);
length += strlen (prefix);
- strcpy (tmp + length, tree_code_name[code]);
- length += strlen (tree_code_name[code]);
+ strcpy (tmp + length, get_tree_code_name (code));
+ length += strlen (get_tree_code_name (code));
}
va_end (args);
}
buffer = "unexpected node";
internal_error ("tree check: %s, have %s in %s, at %s:%d",
- buffer, tree_code_name[TREE_CODE (node)],
+ buffer, get_tree_code_name (TREE_CODE (node)),
function, trim_filename (file), line);
}
va_list args;
char *buffer;
unsigned length = 0;
- int code;
+ enum tree_code code;
va_start (args, function);
- while ((code = va_arg (args, int)))
- length += 4 + strlen (tree_code_name[code]);
+ while ((code = (enum tree_code) va_arg (args, int)))
+ length += 4 + strlen (get_tree_code_name (code));
va_end (args);
va_start (args, function);
buffer = (char *) alloca (length);
length = 0;
- while ((code = va_arg (args, int)))
+ while ((code = (enum tree_code) va_arg (args, int)))
{
if (length)
{
strcpy (buffer + length, " or ");
length += 4;
}
- strcpy (buffer + length, tree_code_name[code]);
- length += strlen (tree_code_name[code]);
+ strcpy (buffer + length, get_tree_code_name (code));
+ length += strlen (get_tree_code_name (code));
}
va_end (args);
internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
- buffer, tree_code_name[TREE_CODE (node)],
+ buffer, get_tree_code_name (TREE_CODE (node)),
function, trim_filename (file), line);
}
("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
TREE_CODE_CLASS_STRING (cl),
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
- tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
+ get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
}
/* Similar to tree_check_failed, except that instead of specifying a
unsigned int c;
for (c = c1; c <= c2; ++c)
- length += 4 + strlen (tree_code_name[c]);
+ length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
length += strlen ("expected ");
buffer = (char *) alloca (length);
strcpy (buffer + length, prefix);
length += strlen (prefix);
- strcpy (buffer + length, tree_code_name[c]);
- length += strlen (tree_code_name[c]);
+ strcpy (buffer + length, get_tree_code_name ((enum tree_code) c));
+ length += strlen (get_tree_code_name ((enum tree_code) c));
}
internal_error ("tree check: %s, have %s in %s, at %s:%d",
- buffer, tree_code_name[TREE_CODE (node)],
+ buffer, get_tree_code_name (TREE_CODE (node)),
function, trim_filename (file), line);
}
("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
TREE_CODE_CLASS_STRING (cl),
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
- tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
+ get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
}
const char *function, enum omp_clause_code code)
{
internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
- omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
+ omp_clause_code_name[code], get_tree_code_name (TREE_CODE (node)),
function, trim_filename (file), line);
}
internal_error
("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
TS_ENUM_NAME (en),
- tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
+ get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
}
tree_operand_check_failed (int idx, const_tree exp, const char *file,
int line, const char *function)
{
- int code = TREE_CODE (exp);
+ enum tree_code code = TREE_CODE (exp);
internal_error
("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
- idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
+ idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
function, trim_filename (file), line);
}
return using_eh_for_cleanups_flag;
}
+/* Wrapper for tree_code_name to ensure that tree code is valid */
+const char *
+get_tree_code_name (enum tree_code code)
+{
+ const char *invalid = "<invalid tree code>";
+
+ if (code >= MAX_TREE_CODES)
+ return invalid;
+
+ return tree_code_name[code];
+}
+
#include "gt-tree.h"
extern void using_eh_for_cleanups (void);
extern bool using_eh_for_cleanups_p (void);
+extern const char *get_tree_code_name (enum tree_code);
+
/* In tree-nested.c */
extern tree build_addr (tree, tree);