This is the mail archive of the
gcc@gcc.gnu.org
mailing list for the GCC project.
successfully removed the convert callback
- From: "Rafael EspÃndola" <rafael dot espindola at gmail dot com>
- To: "GCC Mailing List" <gcc at gcc dot gnu dot org>
- Date: Fri, 31 Mar 2006 22:20:16 -0300
- Subject: successfully removed the convert callback
The attached patch removes the convert callback by
1) copying the c implementation of convert to convert2
2) changing all calls to convert in gcj and gfortran into calls to convert2
3) adding a lang prefix to the remaining implementations (cxx_, c_, gnat_)
4) renaming all convert calls in a front end to the corresponding implementation
5) coping convert_and_check and constant_fits_type_p into the c++
front end so that it doesn't try to use convert2
6) renaming all the remaining calls to convert into convert2
7) removing the treelang, java and fortran implementation of convert
This patch was bootstraped and regtested on a x86 without any regressions!
I found a bit strange that there were no java regression since
convert_ieee_real_to_integer is no longer used. Is a testcase missing?
I will as soon as possible move item 5 into a patch of its on and
submit. I will then clean up the tons of dead code that I have added,
rename convert2 back to convert, move it to a better place,
reintroduce java_convert if needed and finally submit a patch.
I will be a bit busy, so I think that I will be able to do just the
first step during next week :-(
Best Regards,
Rafael
Index: gcc/java/java-gimplify.c
===================================================================
--- gcc/java/java-gimplify.c (revision 112530)
+++ gcc/java/java-gimplify.c (working copy)
@@ -31,6 +31,7 @@
#include "tree-dump.h"
#include "tree-gimple.h"
#include "toplev.h"
+#include "java/convert.h"
static tree java_gimplify_labeled_block_expr (tree);
static tree java_gimplify_exit_block_expr (tree);
@@ -233,7 +234,7 @@
/* Fix up type mismatches to make legal GIMPLE. These are
generated in several places, in particular null pointer
assignment and subclass assignment. */
- TREE_OPERAND (modify_expr, 1) = convert (lhs_type, rhs);
+ TREE_OPERAND (modify_expr, 1) = convert2 (lhs_type, rhs);
return modify_expr;
}
Index: gcc/java/typeck.c
===================================================================
--- gcc/java/typeck.c (revision 112530)
+++ gcc/java/typeck.c (working copy)
@@ -25,7 +25,7 @@
/* Written by Per Bothner <bothner@cygnus.com> */
-#include "config.h"
+#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
@@ -39,7 +39,7 @@
#include "toplev.h"
#include "ggc.h"
-static tree convert_ieee_real_to_integer (tree, tree);
+/* static tree convert_ieee_real_to_integer (tree, tree); */
static tree parse_signature_type (const unsigned char **,
const unsigned char *);
static tree lookup_do (tree, int, tree, tree, tree (*)(tree));
@@ -76,87 +76,34 @@
? 0
: (int)expr))) */
-static tree
-convert_ieee_real_to_integer (tree type, tree expr)
-{
- tree result;
- expr = save_expr (expr);
+/* static tree */
+/* convert_ieee_real_to_integer (tree type, tree expr) */
+/* { */
+/* tree result; */
+/* expr = save_expr (expr); */
- result = fold_build3 (COND_EXPR, type,
- fold_build2 (NE_EXPR, boolean_type_node, expr, expr),
- convert (type, integer_zero_node),
- convert_to_integer (type, expr));
+/* result = fold_build3 (COND_EXPR, type, */
+/* fold_build2 (NE_EXPR, boolean_type_node, expr, expr), */
+/* convert2 (type, integer_zero_node), */
+/* convert_to_integer (type, expr)); */
- result = fold_build3 (COND_EXPR, type,
- fold_build2 (LE_EXPR, boolean_type_node, expr,
- convert (TREE_TYPE (expr),
- TYPE_MIN_VALUE (type))),
- TYPE_MIN_VALUE (type),
- result);
+/* result = fold_build3 (COND_EXPR, type, */
+/* fold_build2 (LE_EXPR, boolean_type_node, expr, */
+/* convert2 (TREE_TYPE (expr), */
+/* TYPE_MIN_VALUE (type))), */
+/* TYPE_MIN_VALUE (type), */
+/* result); */
- result = fold_build3 (COND_EXPR, type,
- fold_build2 (GE_EXPR, boolean_type_node, expr,
- convert (TREE_TYPE (expr),
- TYPE_MAX_VALUE (type))),
- TYPE_MAX_VALUE (type),
- result);
+/* result = fold_build3 (COND_EXPR, type, */
+/* fold_build2 (GE_EXPR, boolean_type_node, expr, */
+/* convert2 (TREE_TYPE (expr), */
+/* TYPE_MAX_VALUE (type))), */
+/* TYPE_MAX_VALUE (type), */
+/* result); */
- return result;
-}
+/* return result; */
+/* } */
-/* Create an expression whose value is that of EXPR,
- converted to type TYPE. The TREE_TYPE of the value
- is always TYPE. This function implements all reasonable
- conversions; callers should filter out those that are
- not permitted by the language being compiled. */
-
-tree
-convert (tree type, tree expr)
-{
- enum tree_code code = TREE_CODE (type);
-
- if (!expr)
- return error_mark_node;
-
- if (type == TREE_TYPE (expr)
- || TREE_CODE (expr) == ERROR_MARK)
- return expr;
- if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
- return error_mark_node;
- if (code == VOID_TYPE)
- return build1 (CONVERT_EXPR, type, expr);
- if (code == BOOLEAN_TYPE)
- return fold_convert (type, expr);
- if (code == INTEGER_TYPE)
- {
- if (type == char_type_node || type == promoted_char_type_node)
- return fold_convert (type, expr);
- if ((really_constant_p (expr)
- || (! flag_unsafe_math_optimizations
- && ! flag_emit_class_files))
- && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
- && TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
- return convert_ieee_real_to_integer (type, expr);
- else
- {
- /* fold very helpfully sets the overflow status if a type
- overflows in a narrowing integer conversion, but Java
- doesn't care. */
- tree tmp = fold (convert_to_integer (type, expr));
- if (TREE_CODE (tmp) == INTEGER_CST)
- TREE_OVERFLOW (tmp) = 0;
- return tmp;
- }
- }
- if (code == REAL_TYPE)
- return fold (convert_to_real (type, expr));
- if (code == POINTER_TYPE)
- return fold (convert_to_pointer (type, expr));
- error ("conversion to non-scalar type requested");
- return error_mark_node;
-}
-
-
/* Return a data type that has machine mode MODE.
If the mode is an integer,
then UNSIGNEDP selects between signed and unsigned types. */
@@ -903,31 +850,31 @@
if (t1 == double_type_node || t2 == double_type_node)
{
if (t1 != double_type_node)
- *exp1 = convert (double_type_node, *exp1);
+ *exp1 = convert2 (double_type_node, *exp1);
if (t2 != double_type_node)
- *exp2 = convert (double_type_node, *exp2);
+ *exp2 = convert2 (double_type_node, *exp2);
return double_type_node;
}
if (t1 == float_type_node || t2 == float_type_node)
{
if (t1 != float_type_node)
- *exp1 = convert (float_type_node, *exp1);
+ *exp1 = convert2 (float_type_node, *exp1);
if (t2 != float_type_node)
- *exp2 = convert (float_type_node, *exp2);
+ *exp2 = convert2 (float_type_node, *exp2);
return float_type_node;
}
if (t1 == long_type_node || t2 == long_type_node)
{
if (t1 != long_type_node)
- *exp1 = convert (long_type_node, *exp1);
+ *exp1 = convert2 (long_type_node, *exp1);
if (t2 != long_type_node)
- *exp2 = convert (long_type_node, *exp2);
+ *exp2 = convert2 (long_type_node, *exp2);
return long_type_node;
}
if (t1 != int_type_node)
- *exp1 = convert (int_type_node, *exp1);
+ *exp1 = convert2 (int_type_node, *exp1);
if (t2 != int_type_node)
- *exp2 = convert (int_type_node, *exp2);
+ *exp2 = convert2 (int_type_node, *exp2);
return int_type_node;
}
Index: gcc/java/parse.y
===================================================================
--- gcc/java/parse.y (revision 112530)
+++ gcc/java/parse.y (working copy)
@@ -66,6 +66,7 @@
#include "parse.h"
#include "zipfile.h"
#include "convert.h"
+#include "java/convert.h"
#include "buffer.h"
#include "function.h"
#include "except.h"
@@ -11025,7 +11026,7 @@
t = TREE_CHAIN (t), ta = TREE_CHAIN (ta))
if (JPRIMITIVE_TYPE_P (TREE_TYPE (TREE_VALUE (ta))) &&
TREE_TYPE (TREE_VALUE (ta)) != TREE_VALUE (t))
- TREE_VALUE (ta) = convert (TREE_VALUE (t), TREE_VALUE (ta));
+ TREE_VALUE (ta) = convert2 (TREE_VALUE (t), TREE_VALUE (ta));
/* Resolve unresolved returned type issues */
t = TREE_TYPE (TREE_TYPE (method));
@@ -11895,7 +11896,7 @@
return error_mark_node;
}
- cn = fold (convert (int_type_node, cn));
+ cn = fold (convert2 (int_type_node, cn));
TREE_CONSTANT_OVERFLOW (cn) = 0;
CAN_COMPLETE_NORMALLY (cn) = 1;
@@ -12104,7 +12105,7 @@
for (cn = TREE_OPERAND (node, 1); cn; cn = TREE_CHAIN (cn))
{
int location = EXPR_WFL_LINECOL (TREE_VALUE (cn));
- tree dim = convert (int_type_node,
+ tree dim = convert2 (int_type_node,
java_complete_tree (TREE_VALUE (cn)));
if (dim == error_mark_node)
{
@@ -12928,7 +12929,7 @@
/* 15.25.2 If we have a compound assignment, convert RHS into the
type of the LHS */
else if (COMPOUND_ASSIGN_P (TREE_OPERAND (node, 1)))
- new_rhs = convert (lhs_type, rhs);
+ new_rhs = convert2 (lhs_type, rhs);
/* Explicit cast required. This is an error */
if (!new_rhs)
@@ -12978,7 +12979,7 @@
/* If we're processing a `return' statement, promote the actual type
to the promoted type. */
if (is_return)
- new_rhs = convert (TREE_TYPE (lvalue), new_rhs);
+ new_rhs = convert2 (TREE_TYPE (lvalue), new_rhs);
/* 10.10: Array Store Exception runtime check */
if (!flag_emit_class_files
@@ -13119,7 +13120,7 @@
/* 5.1.1 Try Identity Conversion,
5.1.2 Try Widening Primitive Conversion */
else if (valid_builtin_assignconv_identity_widening_p (lhs_type, rhs_type))
- new_rhs = convert (lhs_type, rhs);
+ new_rhs = convert2 (lhs_type, rhs);
/* Try a narrowing primitive conversion (5.1.3):
- expression is a constant expression of type byte, short, char,
@@ -13134,7 +13135,7 @@
|| lhs_type == short_type_node))
{
if (int_fits_type_p (rhs, lhs_type))
- new_rhs = convert (lhs_type, rhs);
+ new_rhs = convert2 (lhs_type, rhs);
else if (wfl_op1) /* Might be called with a NULL */
parse_warning_context
(wfl_op1,
@@ -13353,7 +13354,7 @@
{
tree type = TREE_TYPE (arg);
if (TREE_CODE (type) == INTEGER_TYPE && TYPE_PRECISION (type) < 32)
- arg = convert (int_type_node, arg);
+ arg = convert2 (int_type_node, arg);
return arg;
}
@@ -13700,10 +13701,10 @@
{
tree to_return;
tree utype = java_unsigned_type (prom_type);
- op1 = convert (utype, op1);
+ op1 = convert2 (utype, op1);
to_return = fold_build2 (RSHIFT_EXPR, utype, op1, op2);
- to_return = convert (prom_type, to_return);
+ to_return = convert2 (prom_type, to_return);
/* Copy the original value of the COMPOUND_ASSIGN_P flag */
COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
TREE_SIDE_EFFECTS (to_return)
@@ -14162,7 +14163,7 @@
/* ??? Guessing that the class file code can't handle casts. */
if (! flag_emit_class_files)
- node = convert (string_ptr_type_node, node);
+ node = convert2 (string_ptr_type_node, node);
else
TREE_TYPE (node) = string_ptr_type_node;
@@ -14413,7 +14414,7 @@
if (JINTEGRAL_TYPE_P (op_type))
return fold (node);
else
- return fold (convert (op_type, node));
+ return fold (convert2 (op_type, node));
}
break;
@@ -14559,12 +14560,12 @@
integral type requires special handling (5.1.3). */
if (JFLOAT_TYPE_P (op_type) && JINTEGRAL_TYPE_P (cast_type))
if (cast_type != long_type_node)
- op = convert (integer_type_node, op);
+ op = convert2 (integer_type_node, op);
/* Try widening/narrowing conversion. Potentially, things need
to be worked out in gcc so we implement the extreme cases
correctly. fold_convert() needs to be fixed. */
- return convert (cast_type, op);
+ return convert2 (cast_type, op);
}
/* It's also valid to cast a boolean into a boolean */
Index: gcc/java/class.c
===================================================================
--- gcc/java/class.c (revision 112530)
+++ gcc/java/class.c (working copy)
@@ -46,6 +46,7 @@
#include "cgraph.h"
#include "tree-iterator.h"
#include "cgraph.h"
+#include "java/convert.h"
/* DOS brain-damage */
#ifndef O_BINARY
@@ -940,7 +941,7 @@
tree cl;
index = alloc_class_constant (type);
cl = build_ref_from_constant_pool (index);
- return convert (promote_type (class_ptr_type), cl);
+ return convert2 (promote_type (class_ptr_type), cl);
}
/* Build a reference to the class TYPE.
@@ -1503,7 +1504,7 @@
if (method_index != NULL_TREE)
{
/* method_index is null if we're using indirect dispatch. */
- method_index = fold (convert (sizetype, method_index));
+ method_index = fold (convert2 (sizetype, method_index));
if (TARGET_VTABLE_USES_DESCRIPTORS)
/* Add one to skip bogus descriptor for class and GC descriptor. */
@@ -1913,8 +1914,8 @@
PUSH_FIELD_VALUE (cons, "interface_count",
build_int_cst (NULL_TREE, interface_len));
PUSH_FIELD_VALUE (cons, "state",
- convert (byte_type_node,
- build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
+ convert2 (byte_type_node,
+ build_int_cst (NULL_TREE, JV_STATE_PRELOADING)));
PUSH_FIELD_VALUE (cons, "thread", null_pointer_node);
PUSH_FIELD_VALUE (cons, "depth", integer_zero_node);
@@ -2241,7 +2242,7 @@
/* Convert the size back to an SI integer value. */
TYPE_SIZE_UNIT (this_class) =
- fold (convert (int_type_node, TYPE_SIZE_UNIT (this_class)));
+ fold (convert2 (int_type_node, TYPE_SIZE_UNIT (this_class)));
CLASS_BEING_LAIDOUT (this_class) = 0;
class_list = TREE_CHAIN (class_list);
Index: gcc/java/Make-lang.in
===================================================================
--- gcc/java/Make-lang.in (revision 112530)
+++ gcc/java/Make-lang.in (working copy)
@@ -331,7 +331,7 @@
coretypes.h $(TM_H) intl.h
java/lang.o: java/lang.c $(CONFIG_H) $(JAVA_TREE_H) java/jcf.h input.h \
toplev.h $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(EXPR_H) diagnostic.h \
- langhooks.h $(LANGHOOKS_DEF_H) gt-java-lang.h opts.h options.h
+ langhooks.h $(LANGHOOKS_DEF_H) gt-java-lang.h opts.h options.h java/convert.h
java/mangle.o: java/mangle.c $(CONFIG_H) java/jcf.h $(JAVA_TREE_H) $(SYSTEM_H) \
coretypes.h $(TM_H) toplev.h $(GGC_H) gt-java-mangle.h $(LANGHOOKS_DEF_H)
java/mangle_name.o: java/mangle_name.c $(CONFIG_H) java/jcf.h $(JAVA_TREE_H) \
Index: gcc/java/except.c
===================================================================
--- gcc/java/except.c (revision 112530)
+++ gcc/java/except.c (working copy)
@@ -38,6 +38,7 @@
#include "except.h"
#include "java-except.h"
#include "toplev.h"
+#include "java/convert.h"
static void expand_start_java_handler (struct eh_range *);
static struct eh_range *find_handler_in_range (int, struct eh_range *,
@@ -425,7 +426,7 @@
TYPE_CATCH_CLASSES (output_class));
}
- exp = convert (ptr_type_node, exp);
+ exp = convert2 (ptr_type_node, exp);
*slot = tree_cons (type, exp, NULL_TREE);
Index: gcc/java/jcf-write.c
===================================================================
--- gcc/java/jcf-write.c (revision 112530)
+++ gcc/java/jcf-write.c (working copy)
@@ -39,6 +39,7 @@
#include "toplev.h"
#include "ggc.h"
#include "tm_p.h"
+#include "java/convert.h"
extern struct obstack temporary_obstack;
@@ -2166,7 +2167,7 @@
if (arg0 != NULL_TREE)
generate_bytecode_insns (arg0, target, state);
if (jopcode >= OPCODE_lshl && jopcode <= OPCODE_lushr)
- arg1 = convert (int_type_node, arg1);
+ arg1 = convert2 (int_type_node, arg1);
generate_bytecode_insns (arg1, target, state);
}
/* For most binary operations, both operands and the result have the
Index: gcc/java/expr.c
===================================================================
--- gcc/java/expr.c (revision 112530)
+++ gcc/java/expr.c (working copy)
@@ -45,6 +45,7 @@
#include "ggc.h"
#include "tree-gimple.h"
#include "target.h"
+#include "java/convert.h"
static void flush_quick_stack (void);
static void push_value (tree);
@@ -284,7 +285,7 @@
if (TYPE_PRECISION (type) < 32 && INTEGRAL_TYPE_P (type))
{
type = promote_type (type);
- value = convert (type, value);
+ value = convert2 (type, value);
}
push_type (type);
if (tree_list_free_list == NULL_TREE)
@@ -858,7 +859,7 @@
{
tree t;
t = java_check_reference (expr, check);
- t = convert (build_pointer_type (type), t);
+ t = convert2 (build_pointer_type (type), t);
return build1 (INDIRECT_REF, type, t);
}
@@ -890,10 +891,10 @@
* Note this is equivalent to and more efficient than:
* INDEX < 0 || INDEX >= LEN && throw ... */
tree test;
- tree len = convert (unsigned_int_type_node,
+ tree len = convert2 (unsigned_int_type_node,
build_java_array_length_access (array));
test = fold_build2 (GE_EXPR, boolean_type_node,
- convert (unsigned_int_type_node, index),
+ convert2 (unsigned_int_type_node, index),
len);
if (! integer_zerop (test))
{
@@ -1275,7 +1276,7 @@
copy = build_decl (VAR_DECL, NULL_TREE, type);
if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
&& TREE_TYPE (copy) != TREE_TYPE (var))
- var = convert (type, var);
+ var = convert2 (type, var);
java_add_local_var (copy);
java_add_stmt (build2 (MODIFY_EXPR, TREE_TYPE (var), copy, var));
@@ -1455,8 +1456,8 @@
build_java_soft_divmod (enum tree_code op, tree type, tree op1, tree op2)
{
tree call = NULL;
- tree arg1 = convert (type, op1);
- tree arg2 = convert (type, op2);
+ tree arg1 = convert2 (type, op1);
+ tree arg2 = convert2 (type, op2);
if (type == int_type_node)
{
@@ -1506,9 +1507,9 @@
case URSHIFT_EXPR:
{
tree u_type = java_unsigned_type (type);
- arg1 = convert (u_type, arg1);
+ arg1 = convert2 (u_type, arg1);
arg1 = build_java_binop (RSHIFT_EXPR, u_type, arg1, arg2);
- return convert (type, arg1);
+ return convert2 (type, arg1);
}
case LSHIFT_EXPR:
case RSHIFT_EXPR:
@@ -1553,8 +1554,8 @@
tree call;
if (type != double_type_node)
{
- arg1 = convert (double_type_node, arg1);
- arg2 = convert (double_type_node, arg2);
+ arg1 = convert2 (double_type_node, arg1);
+ arg2 = convert2 (double_type_node, arg2);
}
call = build3 (CALL_EXPR, double_type_node,
build_address_of (soft_fmod_node),
@@ -1562,7 +1563,7 @@
build_tree_list (NULL_TREE, arg2)),
NULL_TREE);
if (type != double_type_node)
- call = convert (type, call);
+ call = convert2 (type, call);
return call;
}
@@ -1707,7 +1708,7 @@
NULL_TREE),
field_offset);
- field_offset = fold (convert (sizetype, field_offset));
+ field_offset = fold (convert2 (sizetype, field_offset));
address
= fold_build2 (PLUS_EXPR,
build_pointer_type (TREE_TYPE (field_decl)),
@@ -1880,7 +1881,7 @@
else if (targetm.calls.promote_prototypes (type)
&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
&& INTEGRAL_TYPE_P (type))
- arg = convert (integer_type_node, arg);
+ arg = convert2 (integer_type_node, arg);
return tree_cons (NULL_TREE, arg, tail);
}
gcc_unreachable ();
@@ -2026,7 +2027,7 @@
TYPE_ATABLE_DECL (output_class), table_index,
NULL_TREE, NULL_TREE);
}
- func = convert (method_ptr_type_node, func);
+ func = convert2 (method_ptr_type_node, func);
}
else
{
@@ -2168,7 +2169,7 @@
}
func = fold_build2 (PLUS_EXPR, nativecode_ptr_ptr_type_node, dtable,
- convert (nativecode_ptr_ptr_type_node, method_index));
+ convert2 (nativecode_ptr_ptr_type_node, method_index));
if (TARGET_VTABLE_USES_DESCRIPTORS)
func = build1 (NOP_EXPR, nativecode_ptr_type_node, func);
@@ -2217,8 +2218,8 @@
TYPE_ITABLE_DECL (output_class),
build_int_cst (NULL_TREE, itable_index),
NULL_TREE, NULL_TREE);
- interface = convert (class_ptr_type, interface);
- idx = convert (integer_type_node, idx);
+ interface = convert2 (class_ptr_type, interface);
+ idx = convert2 (integer_type_node, idx);
}
else
{
@@ -2363,7 +2364,7 @@
if (opcode != OPCODE_invokestatic)
pop_type (self_type);
method_type = promote_type (TREE_TYPE (method_type));
- push_value (convert (method_type, integer_zero_node));
+ push_value (convert2 (method_type, integer_zero_node));
return;
}
@@ -2686,7 +2687,7 @@
if (is_error)
{
if (! is_putting)
- push_value (convert (field_type, integer_zero_node));
+ push_value (convert2 (field_type, integer_zero_node));
flush_quick_stack ();
return;
}
@@ -3010,7 +3011,7 @@
name = get_name_constant (jcf, JPOOL_USHORT1 (jcf, index));
index = alloc_name_constant (CONSTANT_String, name);
c = build_ref_from_constant_pool (index);
- c = convert (promote_type (string_type_node), c);
+ c = convert2 (promote_type (string_type_node), c);
}
else
c = get_constant (jcf, index);
@@ -3208,13 +3209,13 @@
#define CONVERT2(FROM_TYPE, TO_TYPE) \
{ \
push_value (build1 (NOP_EXPR, int_type_node, \
- (convert (TO_TYPE##_type_node, \
+ (convert2 (TO_TYPE##_type_node, \
pop_value (FROM_TYPE##_type_node))))); \
}
#define CONVERT(FROM_TYPE, TO_TYPE) \
{ \
- push_value (convert (TO_TYPE##_type_node, \
+ push_value (convert2 (TO_TYPE##_type_node, \
pop_value (FROM_TYPE##_type_node))); \
}
Index: gcc/java/lang.c
===================================================================
--- gcc/java/lang.c (revision 112530)
+++ gcc/java/lang.c (working copy)
@@ -46,6 +46,7 @@
#include "tree-dump.h"
#include "opts.h"
#include "options.h"
+#include "convert.h"
static bool java_init (void);
static void java_finish (void);
@@ -213,6 +214,7 @@
#undef LANG_HOOKS_SET_DECL_ASSEMBLER_NAME
#define LANG_HOOKS_SET_DECL_ASSEMBLER_NAME java_mangle_decl
+
/* Each front end provides its own. */
const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
Index: gcc/c-lex.c
===================================================================
--- gcc/c-lex.c (revision 112530)
+++ gcc/c-lex.c (working copy)
@@ -689,7 +689,7 @@
/* Create a node with determined type and value. */
value = build_real (type, real);
if (flags & CPP_N_IMAGINARY)
- value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
+ value = build_complex (NULL_TREE, convert2 (type, integer_zero_node), value);
return value;
}
Index: gcc/tree.c
===================================================================
--- gcc/tree.c (revision 112530)
+++ gcc/tree.c (working copy)
@@ -5021,8 +5021,8 @@
if (type == NULL_TREE)
type = sizetype;
- TYPE_MIN_VALUE (itype) = convert (type, lowval);
- TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
+ TYPE_MIN_VALUE (itype) = convert2 (type, lowval);
+ TYPE_MAX_VALUE (itype) = highval ? convert2 (type, highval) : NULL;
TYPE_PRECISION (itype) = TYPE_PRECISION (type);
TYPE_MODE (itype) = TYPE_MODE (type);
Index: gcc/tree.h
===================================================================
--- gcc/tree.h (revision 112530)
+++ gcc/tree.h (working copy)
@@ -3806,7 +3806,7 @@
extern tree non_lvalue (tree);
-extern tree convert (tree, tree);
+extern tree convert2 (tree, tree);
extern unsigned int expr_align (tree);
extern tree expr_first (tree);
extern tree expr_last (tree);
Index: gcc/builtins.c
===================================================================
--- gcc/builtins.c (revision 112530)
+++ gcc/builtins.c (working copy)
@@ -4295,7 +4295,7 @@
static tree
dummy_object (tree type)
{
- tree t = convert (build_pointer_type (type), null_pointer_node);
+ tree t = convert2 (build_pointer_type (type), null_pointer_node);
return build1 (INDIRECT_REF, type, t);
}
@@ -9657,7 +9657,7 @@
if (call && retval)
{
- retval = convert
+ retval = convert2
(TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
retval);
return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
Index: gcc/objc/objc-act.c
===================================================================
--- gcc/objc/objc-act.c (revision 112530)
+++ gcc/objc/objc-act.c (working copy)
@@ -825,14 +825,14 @@
size_binop (PLUS_EXPR,
size_binop
(MULT_EXPR,
- convert (bitsizetype,
+ convert2 (bitsizetype,
DECL_FIELD_OFFSET (field)),
bitsize_int (BITS_PER_UNIT)),
DECL_FIELD_BIT_OFFSET (field)),
DECL_SIZE (field))
: bitsize_zero_node);
DECL_SIZE_UNIT (base)
- = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
+ = size_binop (FLOOR_DIV_EXPR,convert2 (sizetype, DECL_SIZE (base)),
size_int (BITS_PER_UNIT));
DECL_ARTIFICIAL (base) = 1;
DECL_ALIGN (base) = 1;
@@ -1966,7 +1966,7 @@
desc->constructor = constructor;
}
- addr = convert (build_pointer_type (constant_string_type),
+ addr =convert2 (build_pointer_type (constant_string_type),
build_unary_op (ADDR_EXPR, desc->constructor, 1));
return addr;
@@ -2155,7 +2155,7 @@
else
initlist
= tree_cons (NULL_TREE,
- convert (build_pointer_type (objc_selector_type),
+ convert2 (build_pointer_type (objc_selector_type),
build_unary_op (ADDR_EXPR,
UOBJC_SELECTOR_TABLE_decl, 1)),
initlist);
@@ -2250,7 +2250,7 @@
/* size = { ..., sizeof (struct _objc_module), ... } */
- expr = convert (long_integer_type_node,
+ expr =convert2 (long_integer_type_node,
size_in_bytes (objc_module_template));
initlist = tree_cons (NULL_TREE, expr, initlist);
@@ -2501,7 +2501,7 @@
static tree
build_selector (tree ident)
{
- return convert (objc_selector_type,
+ return convert2 (objc_selector_type,
add_objc_string (ident, meth_var_names));
}
@@ -2633,7 +2633,7 @@
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_cst (NULL_TREE, index)),
1);
- return convert (objc_selector_type, expr);
+ return convert2 (objc_selector_type, expr);
}
static tree
@@ -2798,7 +2798,7 @@
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
- return convert (string_type_node,
+ return convert2 (string_type_node,
build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1));
chain = &TREE_CHAIN (*chain);
@@ -2818,7 +2818,7 @@
*chain = tree_cons (decl, ident, NULL_TREE);
- return convert (string_type_node, build_unary_op (ADDR_EXPR, decl, 1));
+ return convert2 (string_type_node, build_unary_op (ADDR_EXPR, decl, 1));
}
static GTY(()) int class_names_idx;
@@ -3067,17 +3067,17 @@
*/
tree offs
= objc_substitute_decl
- (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
+ (lhs, outervar,convert2 (TREE_TYPE (outervar), integer_zero_node));
tree func
= (flag_objc_direct_dispatch
? objc_assign_ivar_fast_decl
: objc_assign_ivar_decl);
- offs = convert (integer_type_node, build_unary_op (ADDR_EXPR, offs, 0));
+ offs =convert2 (integer_type_node, build_unary_op (ADDR_EXPR, offs, 0));
offs = fold (offs);
func_params = tree_cons (NULL_TREE,
- convert (objc_object_type, rhs),
- tree_cons (NULL_TREE, convert (objc_object_type, outervar),
+ convert2 (objc_object_type, rhs),
+ tree_cons (NULL_TREE,convert2 (objc_object_type, outervar),
tree_cons (NULL_TREE, offs,
NULL_TREE)));
@@ -3089,8 +3089,8 @@
objc_build_global_assignment (tree lhs, tree rhs)
{
tree func_params = tree_cons (NULL_TREE,
- convert (objc_object_type, rhs),
- tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
+ convert2 (objc_object_type, rhs),
+ tree_cons (NULL_TREE,convert2 (build_pointer_type (objc_object_type),
build_unary_op (ADDR_EXPR, lhs, 0)),
NULL_TREE));
@@ -3102,8 +3102,8 @@
objc_build_strong_cast_assignment (tree lhs, tree rhs)
{
tree func_params = tree_cons (NULL_TREE,
- convert (objc_object_type, rhs),
- tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
+ convert2 (objc_object_type, rhs),
+ tree_cons (NULL_TREE,convert2 (build_pointer_type (objc_object_type),
build_unary_op (ADDR_EXPR, lhs, 0)),
NULL_TREE));
@@ -3525,11 +3525,11 @@
#ifdef OBJCPLUS
/* Convert _setjmp argument to type that is expected. */
if (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl)))
- t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
+ t =convert2 (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
else
- t = convert (ptr_type_node, t);
+ t =convert2 (ptr_type_node, t);
#else
- t = convert (ptr_type_node, t);
+ t =convert2 (ptr_type_node, t);
#endif
t = tree_cons (NULL, t, NULL);
sj = build_function_call (objc_setjmp_decl, t);
@@ -3552,7 +3552,7 @@
t = build_fold_addr_expr (cur_try_context->stack_decl);
t = tree_cons (NULL, t, NULL);
t = build_function_call (objc_exception_extract_decl, t);
- t = convert (TREE_TYPE (decl), t);
+ t =convert2 (TREE_TYPE (decl), t);
t = build2 (MODIFY_EXPR, void_type_node, decl, t);
return t;
@@ -3686,7 +3686,7 @@
/* Initialize rethrow_decl. */
t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
- convert (objc_object_type, null_pointer_node));
+ convert2 (objc_object_type, null_pointer_node));
SET_EXPR_LOCATION (t, cur_try_context->try_locus);
append_to_statement_list (t, &BIND_EXPR_BODY (bind));
@@ -3824,7 +3824,7 @@
/* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
t = objc_build_exc_ptr ();
- t = convert (TREE_TYPE (decl), t);
+ t =convert2 (TREE_TYPE (decl), t);
t = build2 (MODIFY_EXPR, void_type_node, decl, t);
add_stmt (t);
}
@@ -4663,7 +4663,7 @@
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
- refs_expr = convert (build_pointer_type (build_pointer_type
+ refs_expr =convert2 (build_pointer_type (build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, refs_decl, 0));
else
@@ -4701,7 +4701,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_method_proto_list_ptr,
+ expr =convert2 (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, instance_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -4710,7 +4710,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_method_proto_list_ptr,
+ expr =convert2 (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -5278,7 +5278,7 @@
elemlist
= tree_cons (NULL_TREE,
- convert (ptr_type_node,
+ convert2 (ptr_type_node,
build_unary_op (ADDR_EXPR,
METHOD_DEFINITION (entries), 1)),
elemlist);
@@ -5505,7 +5505,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_method_list_ptr,
+ expr =convert2 (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, instance_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -5513,7 +5513,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_method_list_ptr,
+ expr =convert2 (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -5523,7 +5523,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (build_pointer_type
+ expr =convert2 (build_pointer_type
(build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, protocol_list, 0));
@@ -5582,7 +5582,7 @@
initlist);
/* instance_size = */
- initlist = tree_cons (NULL_TREE, convert (long_integer_type_node, size),
+ initlist = tree_cons (NULL_TREE,convert2 (long_integer_type_node, size),
initlist);
/* objc_ivar_list = */
@@ -5590,7 +5590,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_ivar_list_ptr,
+ expr =convert2 (objc_ivar_list_ptr,
build_unary_op (ADDR_EXPR, ivar_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -5600,7 +5600,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (objc_method_list_ptr,
+ expr =convert2 (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, dispatch_table, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
@@ -5625,7 +5625,7 @@
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = convert (build_pointer_type
+ expr =convert2 (build_pointer_type
(build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, protocol_list, 0));
@@ -5765,7 +5765,7 @@
= build_shared_structure_initializer
(TREE_TYPE (decl),
root_expr, super_expr, name_expr,
- convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
+ convert2 (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
2 /*CLS_META*/,
UOBJC_CLASS_METHODS_decl,
UOBJC_CLASS_VARIABLES_decl,
@@ -5784,7 +5784,7 @@
(TREE_TYPE (decl),
build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
super_expr, name_expr,
- convert (integer_type_node,
+ convert2 (integer_type_node,
TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
(implementation_template))),
1 /*CLS_FACTORY*/ | cls_flags,
@@ -6581,7 +6581,7 @@
/* ??? Ideally we'd build the reference with objc_protocol_type directly,
if we have it, rather than converting it here. */
- expr = convert (objc_protocol_type, expr);
+ expr =convert2 (objc_protocol_type, expr);
/* The @protocol() expression is being compiled into a pointer to a
statically allocated instance of the Protocol class. To become
@@ -6712,7 +6712,7 @@
paradigm. */
warning (0, "instance variable %qs accessed in class method",
IDENTIFIER_POINTER (id));
- self_decl = convert (objc_instance_type, self_decl); /* cast */
+ self_decl =convert2 (objc_instance_type, self_decl); /* cast */
}
return objc_build_component_ref (build_indirect_ref (self_decl, "->"), id);
@@ -9242,7 +9242,7 @@
type = TREE_TYPE (decl);
expr = add_objc_string (TREE_VALUE (chain), class_names);
- expr = convert (type, expr); /* cast! */
+ expr =convert2 (type, expr); /* cast! */
/* The decl that is the one that we
forward declared in build_class_reference. */
Index: gcc/cp/typeck.c
===================================================================
--- gcc/cp/typeck.c (revision 112530)
+++ gcc/cp/typeck.c (working copy)
@@ -2443,7 +2443,7 @@
allowed with -Wno-pmf-conversions. It only works for
pmf constants. */
e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
- e1 = convert (fntype, e1);
+ e1 = cxx_convert_internal (fntype, e1);
return e1;
}
else
@@ -3181,7 +3181,7 @@
result_type = type1;
error ("ISO C++ forbids comparison between pointer and integer");
}
- else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1))
+ else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1)) /*aqui!!*/
{
op0 = build_ptrmemfunc_access_expr (op0, pfn_identifier);
op1 = cp_convert (TREE_TYPE (op0), integer_zero_node);
@@ -5527,7 +5527,7 @@
{
if (! same_type_p (TREE_TYPE (rhs), lhstype))
/* Call convert to generate an error; see PR 11063. */
- rhs = convert (lhstype, rhs);
+ rhs = cxx_convert_internal (lhstype, rhs);
result = build2 (INIT_EXPR, lhstype, lhs, rhs);
TREE_SIDE_EFFECTS (result) = 1;
return result;
@@ -5974,7 +5974,7 @@
/*c_cast_p=*/0);
if (!DECL_VIRTUAL_P (fn))
- *pfn = convert (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
+ *pfn = cxx_convert_internal (TYPE_PTRMEMFUNC_FN_TYPE (type), build_addr_func (fn));
else
{
/* If we're dealing with a virtual function, we have to adjust 'this'
@@ -6061,7 +6061,7 @@
if (TREE_CODE (type) == VECTOR_TYPE && coder == VECTOR_TYPE
&& vector_types_convertible_p (type, rhstype))
- return convert (type, rhs);
+ return cxx_convert_internal (type, rhs);
if (rhs == error_mark_node || rhstype == error_mark_node)
return error_mark_node;
@@ -6102,7 +6102,7 @@
}
if (objc_compare_types (type, rhstype, parmno, rname))
- return convert (type, rhs);
+ return cxx_convert_internal (type, rhs);
}
/* [expr.ass]
@@ -6503,7 +6503,7 @@
retval = convert_for_initialization
(NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
"return", NULL_TREE, 0);
- retval = convert (valtype, retval);
+ retval = cxx_convert_internal (valtype, retval);
/* If the conversion failed, treat this just like `return;'. */
if (retval == error_mark_node)
Index: gcc/cp/init.c
===================================================================
--- gcc/cp/init.c (revision 112530)
+++ gcc/cp/init.c (working copy)
@@ -180,7 +180,7 @@
initialized are initialized to zero. */
;
else if (SCALAR_TYPE_P (type))
- init = convert (type, integer_zero_node);
+ init = cxx_convert_internal (type, integer_zero_node);
else if (CLASS_TYPE_P (type))
{
tree field;
@@ -784,7 +784,7 @@
vtt_parm,
vtt_index);
vtbl2 = build_indirect_ref (vtbl2, NULL);
- vtbl2 = convert (TREE_TYPE (vtbl), vtbl2);
+ vtbl2 = cxx_convert_internal (TREE_TYPE (vtbl), vtbl2);
/* The actual initializer is the VTT value only in the subobject
constructor. In maybe_clone_body we'll substitute NULL for
@@ -1754,7 +1754,7 @@
our own VLA layout later. */
vla_p = true;
full_type = build_cplus_array_type (type, NULL_TREE);
- index = convert (sizetype, nelts);
+ index = cxx_convert_internal (sizetype, nelts);
index = size_binop (MINUS_EXPR, index, size_one_node);
TYPE_DOMAIN (full_type) = build_index_type (index);
}
@@ -1800,7 +1800,7 @@
size = size_in_bytes (elt_type);
if (array_p)
{
- size = size_binop (MULT_EXPR, size, convert (sizetype, nelts));
+ size = size_binop (MULT_EXPR, size, cxx_convert_internal (sizetype, nelts));
if (vla_p)
{
tree n, bitsize;
@@ -1809,7 +1809,7 @@
necessary in order for the <INIT_EXPR <*foo> <CONSTRUCTOR
...>> to be valid. */
TYPE_SIZE_UNIT (full_type) = size;
- n = convert (bitsizetype, nelts);
+ n = cxx_convert_internal (bitsizetype, nelts);
bitsize = size_binop (MULT_EXPR, TYPE_SIZE (elt_type), n);
TYPE_SIZE (full_type) = bitsize;
}
@@ -2199,7 +2199,7 @@
/* The below is short by the cookie size. */
virtual_size = size_binop (MULT_EXPR, size_exp,
- convert (sizetype, maxindex));
+ cxx_convert_internal (sizetype, maxindex));
tbase = create_temporary_var (ptype);
tbase_init = build_modify_expr (tbase, NOP_EXPR,
@@ -2233,7 +2233,7 @@
/* The below is short by the cookie size. */
virtual_size = size_binop (MULT_EXPR, size_exp,
- convert (sizetype, maxindex));
+ cxx_convert_internal (sizetype, maxindex));
if (! TYPE_VEC_NEW_USES_COOKIE (type))
/* no header */
@@ -2274,7 +2274,7 @@
/* Outermost wrapper: If pointer is null, punt. */
body = fold_build3 (COND_EXPR, void_type_node,
fold_build2 (NE_EXPR, boolean_type_node, base,
- convert (TREE_TYPE (base),
+ cxx_convert_internal (TREE_TYPE (base),
integer_zero_node)),
body, integer_zero_node);
body = build1 (NOP_EXPR, void_type_node, body);
Index: gcc/cp/class.c
===================================================================
--- gcc/cp/class.c (revision 112530)
+++ gcc/cp/class.c (working copy)
@@ -350,7 +350,7 @@
t = TREE_TYPE (TYPE_VFIELD (current_class_type));
t = build_pointer_type (t);
- v_offset = convert (t, current_vtt_parm);
+ v_offset = cxx_convert_internal (t, current_vtt_parm);
v_offset = build_indirect_ref (v_offset, NULL);
}
else
@@ -1325,9 +1325,9 @@
/* A virtual binfo might have been copied from within
another hierarchy. As we're about to use it as a
primary base, make sure the offsets match. */
- delta = size_diffop (convert (ssizetype,
+ delta = size_diffop (cxx_convert_internal (ssizetype,
BINFO_OFFSET (base_binfo)),
- convert (ssizetype,
+ cxx_convert_internal (ssizetype,
BINFO_OFFSET (this_primary)));
propagate_binfo_offsets (this_primary, delta);
@@ -1389,7 +1389,7 @@
another hierarchy. As we're about to use it as a primary
base, make sure the offsets match. */
delta = size_diffop (ssize_int (0),
- convert (ssizetype, BINFO_OFFSET (primary)));
+ cxx_convert_internal (ssizetype, BINFO_OFFSET (primary)));
propagate_binfo_offsets (primary, delta);
}
@@ -2071,14 +2071,14 @@
if (virtual_offset
|| (thunk_binfo && !BINFO_OFFSET_ZEROP (thunk_binfo)))
{
- tree offset = convert (ssizetype, BINFO_OFFSET (thunk_binfo));
+ tree offset = cxx_convert_internal (ssizetype, BINFO_OFFSET (thunk_binfo));
if (virtual_offset)
{
/* We convert via virtual base. Adjust the fixed
offset to be from there. */
offset = size_diffop
- (offset, convert
+ (offset, cxx_convert_internal
(ssizetype, BINFO_OFFSET (virtual_offset)));
}
if (fixed_offset)
@@ -2161,8 +2161,8 @@
if (virtual_base)
/* The `this' pointer needs to be adjusted from the declaration to
the nearest virtual base. */
- delta = size_diffop (convert (ssizetype, BINFO_OFFSET (virtual_base)),
- convert (ssizetype, BINFO_OFFSET (first_defn)));
+ delta = size_diffop (cxx_convert_internal (ssizetype, BINFO_OFFSET (virtual_base)),
+ cxx_convert_internal (ssizetype, BINFO_OFFSET (first_defn)));
else if (lost)
/* If the nearest definition is in a lost primary, we don't need an
entry in our vtable. Except possibly in a constructor vtable,
@@ -2174,9 +2174,9 @@
BINFO to pointing at the base where the final overrider
appears. */
virtual_covariant:
- delta = size_diffop (convert (ssizetype,
+ delta = size_diffop (cxx_convert_internal (ssizetype,
BINFO_OFFSET (TREE_VALUE (overrider))),
- convert (ssizetype, BINFO_OFFSET (binfo)));
+ cxx_convert_internal (ssizetype, BINFO_OFFSET (binfo)));
modify_vtable_entry (t, binfo, overrider_fn, delta, virtuals);
@@ -2679,7 +2679,7 @@
if (w != error_mark_node)
{
- DECL_SIZE (field) = convert (bitsizetype, w);
+ DECL_SIZE (field) = cxx_convert_internal (bitsizetype, w);
DECL_BIT_FIELD (field) = 1;
}
else
@@ -3459,8 +3459,8 @@
hierarchy. Therefore, we may not need to add the entire
OFFSET. */
propagate_binfo_offsets (binfo,
- size_diffop (convert (ssizetype, offset),
- convert (ssizetype,
+ size_diffop (cxx_convert_internal (ssizetype, offset),
+ cxx_convert_internal (ssizetype,
BINFO_OFFSET (binfo))));
}
@@ -3513,7 +3513,7 @@
/* That didn't work. Now, we move forward from the next
available spot in the class. */
atend = true;
- propagate_binfo_offsets (binfo, convert (ssizetype, eoc));
+ propagate_binfo_offsets (binfo, cxx_convert_internal (ssizetype, eoc));
while (1)
{
if (!layout_conflict_p (binfo,
@@ -4261,9 +4261,9 @@
/* Update BINFO's offset. */
BINFO_OFFSET (binfo)
- = convert (sizetype,
+ = cxx_convert_internal (sizetype,
size_binop (PLUS_EXPR,
- convert (ssizetype, BINFO_OFFSET (binfo)),
+ cxx_convert_internal (ssizetype, BINFO_OFFSET (binfo)),
offset));
/* Find the primary base class. */
@@ -4515,7 +4515,7 @@
= size_binop (PLUS_EXPR,
rli->bitpos,
size_binop (MULT_EXPR,
- convert (bitsizetype,
+ cxx_convert_internal (bitsizetype,
size_binop (MINUS_EXPR,
eoc, rli_size)),
bitsize_int (BITS_PER_UNIT)));
@@ -4799,7 +4799,7 @@
eoc = end_of_class (t, /*include_virtuals_p=*/0);
TYPE_SIZE_UNIT (base_t)
= size_binop (MAX_EXPR,
- convert (sizetype,
+ cxx_convert_internal (sizetype,
size_binop (CEIL_DIV_EXPR,
rli_size_so_far (rli),
bitsize_int (BITS_PER_UNIT))),
@@ -4808,7 +4808,7 @@
= size_binop (MAX_EXPR,
rli_size_so_far (rli),
size_binop (MULT_EXPR,
- convert (bitsizetype, eoc),
+ cxx_convert_internal (bitsizetype, eoc),
bitsize_int (BITS_PER_UNIT)));
}
TYPE_ALIGN (base_t) = rli->record_align;
@@ -7453,7 +7453,7 @@
/* Figure out where we can find this vbase offset. */
delta = size_binop (MULT_EXPR,
vid->index,
- convert (ssizetype,
+ cxx_convert_internal (ssizetype,
TYPE_SIZE_UNIT (vtable_entry_type)));
if (vid->primary_vtbl_p)
BINFO_VPTR_FIELD (b) = delta;
Index: gcc/cp/call.c
===================================================================
--- gcc/cp/call.c (revision 112530)
+++ gcc/cp/call.c (working copy)
@@ -4141,7 +4141,57 @@
return expr;
}
+/* Nonzero if constant C has a value that is permissible
+ for type TYPE (an INTEGER_TYPE). */
+static int
+constant_fits_type_p (tree c, tree type)
+{
+ if (TREE_CODE (c) == INTEGER_CST)
+ return int_fits_type_p (c, type);
+
+ c = cxx_convert_internal (type, c);
+ return !TREE_OVERFLOW (c);
+}
+
+/* Convert EXPR to TYPE, warning about conversion problems with constants.
+ Invoke this function on every expression that is converted implicitly,
+ i.e. because of language rules and not because of an explicit cast. */
+
+static tree
+cxx_convert_and_check (tree type, tree expr)
+{
+ tree t = cxx_convert_internal (type, expr);
+ if (TREE_CODE (t) == INTEGER_CST)
+ {
+ if (TREE_OVERFLOW (t))
+ {
+ TREE_OVERFLOW (t) = 0;
+
+ /* Do not diagnose overflow in a constant expression merely
+ because a conversion overflowed. */
+ TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
+
+ /* No warning for converting 0x80000000 to int. */
+ if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
+ && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
+ && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
+ /* If EXPR fits in the unsigned version of TYPE,
+ don't warn unless pedantic. */
+ if ((pedantic
+ || TYPE_UNSIGNED (type)
+ || !constant_fits_type_p (expr,
+ c_common_unsigned_type (type))
+ )
+ && skip_evaluation == 0)
+ warning (0, "overflow in implicit constant conversion");
+ }
+ else
+ unsigned_conversion_warning (t, expr);
+ }
+ return t;
+}
+
/* Perform the conversions in CONVS on the expression EXPR. FN and
ARGNUM are used for diagnostics. ARGNUM is zero based, -1
indicates the `this' argument of a method. INNER is nonzero when
@@ -4413,9 +4463,9 @@
}
if (issue_conversion_warnings)
- expr = convert_and_check (totype, expr);
+ expr = cxx_convert_and_check (totype, expr);
else
- expr = convert (totype, expr);
+ expr = cxx_convert_internal (totype, expr);
return expr;
}
@@ -4497,7 +4547,7 @@
/* Undefined behavior [expr.call] 5.2.2/7. */
warning (0, "cannot receive objects of non-POD type %q#T through %<...%>; "
"call will abort at runtime", type);
- expr = convert (build_pointer_type (type), null_node);
+ expr = cxx_convert_internal (build_pointer_type (type), null_node);
expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr),
call_builtin_trap (), expr);
expr = build_indirect_ref (expr, NULL);
@@ -4917,7 +4967,7 @@
t = implicit_built_in_decls[BUILT_IN_MEMCPY];
t = build_call (t, args);
- t = convert (TREE_TYPE (TREE_VALUE (args)), t);
+ t = cxx_convert_internal (TREE_TYPE (TREE_VALUE (args)), t);
val = build_indirect_ref (t, 0);
}
@@ -5028,7 +5078,7 @@
return error_mark_node;
}
iface_ref = build_address (iface_ref);
- iface_ref = convert (build_pointer_type (iface), iface_ref);
+ iface_ref = cxx_convert_internal (build_pointer_type (iface), iface_ref);
/* Determine the itable index of FN. */
i = 1;
Index: gcc/cp/method.c
===================================================================
--- gcc/cp/method.c (revision 112530)
+++ gcc/cp/method.c (working copy)
@@ -100,7 +100,7 @@
virtual_offset
= size_binop (MULT_EXPR,
virtual_offset,
- convert (ssizetype,
+ cxx_convert_internal (ssizetype,
TYPE_SIZE_UNIT (vtable_entry_type)));
d = tree_low_cst (fixed_offset, 0);
Index: gcc/cp/rtti.c
===================================================================
--- gcc/cp/rtti.c (revision 112530)
+++ gcc/cp/rtti.c (working copy)
@@ -253,7 +253,7 @@
index = build_int_cst (NULL_TREE,
-1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
t = build_vtbl_ref (exp, index);
- t = convert (type_info_ptr_type, t);
+ t = cxx_convert_internal (type_info_ptr_type, t);
}
else
/* Otherwise return the type_info for the static type of the expr. */
@@ -1061,7 +1061,7 @@
/* We store the vtable offset at which the virtual
base offset can be found. */
offset = BINFO_VPTR_FIELD (base_binfo);
- offset = convert (sizetype, offset);
+ offset = cxx_convert_internal (sizetype, offset);
flags |= 1;
}
else
Index: gcc/cp/except.c
===================================================================
--- gcc/cp/except.c (revision 112530)
+++ gcc/cp/except.c (working copy)
@@ -149,7 +149,7 @@
mark_used (exp);
- return convert (ptr_type_node, build_address (exp));
+ return cxx_convert_internal (ptr_type_node, build_address (exp));
}
tree
Index: gcc/cp/cvt.c
===================================================================
--- gcc/cp/cvt.c (revision 112530)
+++ gcc/cp/cvt.c (working copy)
@@ -977,7 +977,7 @@
do a little bit more work. */
tree
-convert (tree type, tree expr)
+cxx_convert_internal (tree type, tree expr)
{
tree intype;
Index: gcc/cp/tree.c
===================================================================
--- gcc/cp/tree.c (revision 112530)
+++ gcc/cp/tree.c (working copy)
@@ -280,7 +280,7 @@
abstract_virtuals_error (NULL_TREE, type);
if (TREE_CODE (init) != CALL_EXPR && TREE_CODE (init) != AGGR_INIT_EXPR)
- return convert (type, init);
+ return cxx_convert_internal (type, init);
fn = TREE_OPERAND (init, 0);
is_ctor = (TREE_CODE (fn) == ADDR_EXPR
Index: gcc/cp/cp-tree.h
===================================================================
--- gcc/cp/cp-tree.h (revision 112530)
+++ gcc/cp/cp-tree.h (working copy)
@@ -3801,6 +3801,8 @@
extern tree perform_qualification_conversions (tree, tree);
extern void clone_function_decl (tree, int);
extern void adjust_clone_args (tree);
+extern tree cxx_convert (tree type, tree expr);
+extern tree cxx_convert_internal (tree type, tree expr);
/* decl.c */
extern tree poplevel (int, int, int);
Index: gcc/cp/cp-gimplify.c
===================================================================
--- gcc/cp/cp-gimplify.c (revision 112530)
+++ gcc/cp/cp-gimplify.c (working copy)
@@ -630,7 +630,7 @@
if (TREE_CODE (stmt) == ADDR_EXPR
&& is_invisiref_parm (TREE_OPERAND (stmt, 0)))
{
- *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
+ *stmt_p = cxx_convert_internal (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
*walk_subtrees = 0;
}
else if (TREE_CODE (stmt) == RETURN_EXPR
Index: gcc/cp/decl2.c
===================================================================
--- gcc/cp/decl2.c (revision 112530)
+++ gcc/cp/decl2.c (working copy)
@@ -2065,13 +2065,13 @@
{
guard_value = integer_one_node;
if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
- guard_value = convert (TREE_TYPE (guard), guard_value);
+ guard_value = cxx_convert_internal (TREE_TYPE (guard), guard_value);
guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value);
}
guard_value = integer_zero_node;
if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard)))
- guard_value = convert (TREE_TYPE (guard), guard_value);
+ guard_value = cxx_convert_internal (TREE_TYPE (guard), guard_value);
return cp_build_binary_op (EQ_EXPR, guard, guard_value);
}
@@ -2087,7 +2087,7 @@
guard = get_guard_bits (guard);
guard_init = integer_one_node;
if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard)))
- guard_init = convert (TREE_TYPE (guard), guard_init);
+ guard_init = cxx_convert_internal (TREE_TYPE (guard), guard_init);
return build_modify_expr (guard, NOP_EXPR, guard_init);
}
Index: gcc/tree-ssa-ccp.c
===================================================================
--- gcc/tree-ssa-ccp.c (revision 112530)
+++ gcc/tree-ssa-ccp.c (working copy)
@@ -1879,7 +1879,7 @@
if (TREE_CODE (min_idx) != INTEGER_CST)
break;
- array_idx = convert (TREE_TYPE (min_idx), array_idx);
+ array_idx = convert2 (TREE_TYPE (min_idx), array_idx);
if (!integer_zerop (min_idx))
array_idx = int_const_binop (MINUS_EXPR, array_idx,
min_idx, 0);
@@ -1887,7 +1887,7 @@
}
/* Convert the index to a byte offset. */
- array_idx = convert (sizetype, array_idx);
+ array_idx = convert2 (sizetype, array_idx);
array_idx = int_const_binop (MULT_EXPR, array_idx, elt_size, 0);
/* Update the operands for the next round, or for folding. */
Index: gcc/dojump.c
===================================================================
--- gcc/dojump.c (revision 112530)
+++ gcc/dojump.c (working copy)
@@ -277,7 +277,7 @@
&& (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
!= CODE_FOR_nothing))
{
- do_jump (convert (type, exp), if_false_label, if_true_label);
+ do_jump (convert2 (type, exp), if_false_label, if_true_label);
break;
}
goto normal;
@@ -336,7 +336,7 @@
&& (cmp_optab->handlers[(int) TYPE_MODE (type)].insn_code
!= CODE_FOR_nothing))
{
- do_jump (convert (type, exp), if_false_label, if_true_label);
+ do_jump (convert2 (type, exp), if_false_label, if_true_label);
break;
}
goto normal;
Index: gcc/c-tree.h
===================================================================
--- gcc/c-tree.h (revision 112530)
+++ gcc/c-tree.h (working copy)
@@ -436,6 +436,8 @@
extern tree pop_scope (void);
extern void insert_block (tree);
extern void c_expand_body (tree);
+extern tree c_convert (tree type, tree expr);
+extern tree c_convert_internal (tree type, tree expr);
extern void c_init_decl_processing (void);
extern void c_dup_lang_specific_decl (tree);
Index: gcc/expr.c
===================================================================
--- gcc/expr.c (revision 112530)
+++ gcc/expr.c (working copy)
@@ -4239,11 +4239,11 @@
{
if (TYPE_UNSIGNED (TREE_TYPE (exp))
!= SUBREG_PROMOTED_UNSIGNED_P (target))
- exp = convert
+ exp = convert2
(lang_hooks.types.signed_or_unsigned_type
(SUBREG_PROMOTED_UNSIGNED_P (target), TREE_TYPE (exp)), exp);
- exp = convert (lang_hooks.types.type_for_mode
+ exp = convert2 (lang_hooks.types.type_for_mode
(GET_MODE (SUBREG_REG (target)),
SUBREG_PROMOTED_UNSIGNED_P (target)),
exp);
@@ -4914,7 +4914,7 @@
{
type = lang_hooks.types.type_for_size
(BITS_PER_WORD, TYPE_UNSIGNED (type));
- value = convert (type, value);
+ value = convert2 (type, value);
}
if (BYTES_BIG_ENDIAN)
@@ -5119,11 +5119,11 @@
/* Assign value to element index. */
position
- = convert (ssizetype,
+ = convert2 (ssizetype,
fold_build2 (MINUS_EXPR, TREE_TYPE (index),
index, TYPE_MIN_VALUE (domain)));
position = size_binop (MULT_EXPR, position,
- convert (ssizetype,
+ convert2 (ssizetype,
TYPE_SIZE_UNIT (elttype)));
pos_rtx = expand_normal (position);
@@ -5169,7 +5169,7 @@
TYPE_MIN_VALUE (domain)));
position = size_binop (MULT_EXPR, index,
- convert (ssizetype,
+ convert2 (ssizetype,
TYPE_SIZE_UNIT (elttype)));
xtarget = offset_address (target,
expand_normal (position),
@@ -5623,7 +5623,7 @@
offset = size_binop (PLUS_EXPR, offset,
size_binop (MULT_EXPR,
- convert (sizetype, index),
+ convert2 (sizetype, index),
unit_size));
}
break;
@@ -5662,7 +5662,7 @@
/* If OFFSET is constant, see if we can return the whole thing as a
constant bit position. Otherwise, split it up. */
if (host_integerp (offset, 0)
- && 0 != (tem = size_binop (MULT_EXPR, convert (bitsizetype, offset),
+ && 0 != (tem = size_binop (MULT_EXPR, convert2 (bitsizetype, offset),
bitsize_unit_node))
&& 0 != (tem = size_binop (PLUS_EXPR, tem, bit_offset))
&& host_integerp (tem, 0))
@@ -8455,7 +8455,7 @@
do_jump (TREE_OPERAND (rhs, 1),
TREE_CODE (rhs) == BIT_IOR_EXPR ? label : 0,
TREE_CODE (rhs) == BIT_AND_EXPR ? label : 0);
- expand_assignment (lhs, convert (TREE_TYPE (rhs),
+ expand_assignment (lhs, convert2 (TREE_TYPE (rhs),
(TREE_CODE (rhs) == BIT_IOR_EXPR
? integer_one_node
: integer_zero_node)));
@@ -8778,7 +8778,7 @@
if (TREE_CODE (array) == STRING_CST)
{
- *ptr_offset = convert (sizetype, offset);
+ *ptr_offset = convert2 (sizetype, offset);
return array;
}
else if (TREE_CODE (array) == VAR_DECL)
@@ -8805,7 +8805,7 @@
/* If variable is bigger than the string literal, OFFSET must be constant
and inside of the bounds of the string literal. */
- offset = convert (sizetype, offset);
+ offset = convert2 (sizetype, offset);
if (compare_tree_int (DECL_SIZE_UNIT (array), length) > 0
&& (! host_integerp (offset, 1)
|| compare_tree_int (offset, length) >= 0))
@@ -9117,7 +9117,7 @@
{
if (TYPE_MODE (index_type) != index_mode)
{
- index_expr = convert (lang_hooks.types.type_for_size
+ index_expr = convert2 (lang_hooks.types.type_for_size
(index_bits, 0), index_expr);
index_type = TREE_TYPE (index_expr);
}
@@ -9245,8 +9245,8 @@
return 0;
index_expr = fold_build2 (MINUS_EXPR, index_type,
- convert (index_type, index_expr),
- convert (index_type, minval));
+ convert2 (index_type, index_expr),
+ convert2 (index_type, minval));
index = expand_normal (index_expr);
do_pending_stack_adjust ();
Index: gcc/expr.h
===================================================================
--- gcc/expr.h (revision 112530)
+++ gcc/expr.h (working copy)
@@ -129,10 +129,10 @@
if (host_integerp (inc, 0)) \
(TO).constant += tree_low_cst (inc, 0); \
else if ((TO).var == 0) \
- (TO).var = convert (ssizetype, inc); \
+ (TO).var = convert2 (ssizetype, inc); \
else \
(TO).var = size_binop (PLUS_EXPR, (TO).var, \
- convert (ssizetype, inc)); \
+ convert2 (ssizetype, inc)); \
} while (0)
#define SUB_PARM_SIZE(TO, DEC) \
@@ -142,17 +142,17 @@
(TO).constant -= tree_low_cst (dec, 0); \
else if ((TO).var == 0) \
(TO).var = size_binop (MINUS_EXPR, ssize_int (0), \
- convert (ssizetype, dec)); \
+ convert2 (ssizetype, dec)); \
else \
(TO).var = size_binop (MINUS_EXPR, (TO).var, \
- convert (ssizetype, dec)); \
+ convert2 (ssizetype, dec)); \
} while (0)
/* Convert the implicit sum in a `struct args_size' into a tree
of type ssizetype. */
#define ARGS_SIZE_TREE(SIZE) \
((SIZE).var == 0 ? ssize_int ((SIZE).constant) \
- : size_binop (PLUS_EXPR, convert (ssizetype, (SIZE).var), \
+ : size_binop (PLUS_EXPR, convert2 (ssizetype, (SIZE).var), \
ssize_int ((SIZE).constant)))
/* Convert the implicit sum in a `struct args_size' into an rtx. */
Index: gcc/ada/trans.c
===================================================================
--- gcc/ada/trans.c (revision 112530)
+++ gcc/ada/trans.c (working copy)
@@ -405,7 +405,7 @@
&& DECL_BY_COMPONENT_PTR_P (gnu_result))
gnu_result
= build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (build_pointer_type (gnu_result_type),
+ gnat_convert_internal (build_pointer_type (gnu_result_type),
gnu_result));
/* If it's a renaming pointer and we are at the right binding level,
@@ -595,7 +595,7 @@
= build_binary_op (attribute == Attr_Pred
? MINUS_EXPR : PLUS_EXPR,
gnu_result_type, gnu_expr,
- convert (gnu_result_type, integer_one_node));
+ gnat_convert_internal (gnu_result_type, integer_one_node));
break;
case Attr_Address:
@@ -650,7 +650,7 @@
template address.*/
if (TYPE_FAT_POINTER_P (TREE_TYPE (gnu_ptr)))
gnu_ptr
- = convert (build_pointer_type
+ = gnat_convert_internal (build_pointer_type
(TYPE_OBJECT_RECORD_TYPE
(TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (gnu_ptr)))),
gnu_ptr);
@@ -662,15 +662,15 @@
tree gnu_char_ptr_type = build_pointer_type (char_type_node);
tree gnu_pos = byte_position (TYPE_FIELDS (gnu_obj_type));
tree gnu_byte_offset
- = convert (gnu_char_ptr_type,
+ = gnat_convert_internal (gnu_char_ptr_type,
size_diffop (size_zero_node, gnu_pos));
- gnu_ptr = convert (gnu_char_ptr_type, gnu_ptr);
+ gnu_ptr = gnat_convert_internal (gnu_char_ptr_type, gnu_ptr);
gnu_ptr = build_binary_op (MINUS_EXPR, gnu_char_ptr_type,
gnu_ptr, gnu_byte_offset);
}
- gnu_result = convert (gnu_result_type, gnu_ptr);
+ gnu_result = gnat_convert_internal (gnu_result_type, gnu_ptr);
}
break;
@@ -779,7 +779,7 @@
??? Size should be calculated in storage elements directly. */
if (attribute == Attr_Max_Size_In_Storage_Elements)
- gnu_result = convert (sizetype,
+ gnu_result = gnat_convert_internal (sizetype,
fold (build2 (CEIL_DIV_EXPR, bitsizetype,
gnu_result, bitsize_unit_node)));
break;
@@ -822,12 +822,12 @@
(PLUS_EXPR, get_base_type (gnu_result_type),
build_binary_op (MINUS_EXPR,
get_base_type (gnu_result_type),
- convert (gnu_result_type,
+ gnat_convert_internal (gnu_result_type,
TYPE_MAX_VALUE (gnu_type)),
- convert (gnu_result_type,
+ gnat_convert_internal (gnu_result_type,
TYPE_MIN_VALUE (gnu_type))),
- convert (gnu_result_type, integer_one_node)),
- convert (gnu_result_type, integer_zero_node));
+ gnat_convert_internal (gnu_result_type, integer_one_node)),
+ gnat_convert_internal (gnu_result_type, integer_zero_node));
break;
}
@@ -885,14 +885,14 @@
(PLUS_EXPR, gnu_compute_type,
build_binary_op
(MINUS_EXPR, gnu_compute_type,
- convert (gnu_compute_type,
+ gnat_convert_internal (gnu_compute_type,
TYPE_MAX_VALUE
(TYPE_INDEX_TYPE (TYPE_DOMAIN (gnu_type)))),
- convert (gnu_compute_type,
+ gnat_convert_internal (gnu_compute_type,
TYPE_MIN_VALUE
(TYPE_INDEX_TYPE (TYPE_DOMAIN (gnu_type))))),
- convert (gnu_compute_type, integer_one_node)),
- convert (gnu_compute_type, integer_zero_node));
+ gnat_convert_internal (gnu_compute_type, integer_one_node)),
+ gnat_convert_internal (gnu_compute_type, integer_zero_node));
}
/* If this has a PLACEHOLDER_EXPR, qualify it by the object we are
@@ -1049,7 +1049,7 @@
gnu_result_type = get_unpadded_type (Etype (gnat_node));
gnu_result
= build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (build_pointer_type (gnu_result_type),
+ gnat_convert_internal (build_pointer_type (gnu_result_type),
integer_zero_node));
TREE_PRIVATE (gnu_result) = 1;
break;
@@ -1079,7 +1079,7 @@
&& (DECL_BY_COMPONENT_PTR_P
(get_gnu_tree (gnat_obj))))))
? By_Reference : By_Copy);
- gnu_result = convert (gnu_result_type, size_int (- code));
+ gnu_result = gnat_convert_internal (gnu_result_type, size_int (- code));
}
break;
@@ -1117,7 +1117,7 @@
Node_Id gnat_when;
gnu_expr = gnat_to_gnu (Expression (gnat_node));
- gnu_expr = convert (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
+ gnu_expr = gnat_convert_internal (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
/* The range of values in a case statement is determined by the rules in
RM 5.4(7-9). In almost all cases, this range is represented by the Etype
@@ -1133,7 +1133,7 @@
if (Paren_Count (Expression (gnat_node)) != 0
|| !Is_OK_Static_Subtype (Underlying_Type
(Etype (Expression (gnat_node)))))
- gnu_expr = convert (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
+ gnu_expr = gnat_convert_internal (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
/* We build a SWITCH_EXPR that contains the code with interspersed
CASE_LABEL_EXPRs for each label. */
@@ -1296,7 +1296,7 @@
/* The loop variable might be a padded type, so use `convert' to get a
reference to the inner variable if so. */
- gnu_loop_var = convert (get_base_type (gnu_type), gnu_loop_var);
+ gnu_loop_var = gnat_convert_internal (get_base_type (gnu_type), gnu_loop_var);
/* Set either the top or bottom exit condition as appropriate depending
on whether or not we know an overflow cannot occur. */
@@ -1314,7 +1314,7 @@
: PREINCREMENT_EXPR,
TREE_TYPE (gnu_loop_var),
gnu_loop_var,
- convert (TREE_TYPE (gnu_loop_var),
+ gnat_convert_internal (TREE_TYPE (gnu_loop_var),
integer_one_node));
annotate_with_node (LOOP_STMT_UPDATE (gnu_loop_stmt),
gnat_iter_scheme);
@@ -1497,7 +1497,7 @@
/* Do any needed references for padded types. */
TREE_VALUE (gnu_cico_list)
- = convert (TREE_TYPE (TREE_PURPOSE (gnu_cico_list)),
+ = gnat_convert_internal (TREE_TYPE (TREE_PURPOSE (gnu_cico_list)),
gnat_to_gnu_entity (gnat_param, NULL_TREE, 1));
}
@@ -1773,7 +1773,7 @@
gnu_name = gnu_copy = TREE_OPERAND (gnu_name, 0);
else if (TREE_CODE (gnu_name_type) == RECORD_TYPE
&& (TYPE_JUSTIFIED_MODULAR_P (gnu_name_type)))
- gnu_name = convert (gnu_name_type, gnu_name);
+ gnu_name = gnat_convert_internal (gnu_name_type, gnu_name);
gnu_actual = save_expr (gnu_name);
@@ -1804,7 +1804,7 @@
if (Ekind (gnat_formal) != E_Out_Parameter
&& TREE_CODE (TREE_TYPE (gnu_actual)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_actual)))
- gnu_actual = convert (get_unpadded_type (Etype (gnat_actual)),
+ gnu_actual = gnat_convert_internal (get_unpadded_type (Etype (gnat_actual)),
gnu_actual);
/* Unless this is an In parameter, we must remove any LJM building
@@ -1813,7 +1813,7 @@
&& TREE_CODE (gnu_name) == CONSTRUCTOR
&& TREE_CODE (TREE_TYPE (gnu_name)) == RECORD_TYPE
&& TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (gnu_name)))
- gnu_name = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_name))),
+ gnu_name = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_name))),
gnu_name);
if (Ekind (gnat_formal) != E_Out_Parameter
@@ -1843,11 +1843,11 @@
else if (TREE_CODE (gnu_actual) != SAVE_EXPR)
/* We may have suppressed a conversion to the Etype of the actual since
the parent is a procedure call. So add the conversion here. */
- gnu_actual = convert (gnat_to_gnu_type (Etype (gnat_actual)),
+ gnu_actual = gnat_convert_internal (gnat_to_gnu_type (Etype (gnat_actual)),
gnu_actual);
if (TREE_CODE (gnu_actual) != SAVE_EXPR)
- gnu_actual = convert (gnu_formal_type, gnu_actual);
+ gnu_actual = gnat_convert_internal (gnu_formal_type, gnu_actual);
/* If we have not saved a GCC object for the formal, it means it is an
OUT parameter not passed by reference and that does not need to be
@@ -1864,7 +1864,7 @@
if (TREE_CODE (TREE_TYPE (gnu_actual)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_actual))
&& TREE_CODE (gnu_actual) != SAVE_EXPR)
- gnu_actual = convert (get_unpadded_type (Etype (gnat_actual)),
+ gnu_actual = gnat_convert_internal (get_unpadded_type (Etype (gnat_actual)),
gnu_actual);
/* If we have the constructed subtype of an aliased object
@@ -1878,7 +1878,7 @@
&& TREE_CODE (gnu_actual) != SAVE_EXPR
&& Is_Constr_Subt_For_UN_Aliased (Etype (gnat_actual))
&& Is_Array_Type (Etype (gnat_actual)))
- gnu_actual = convert (gnat_to_gnu_type (Etype (gnat_actual)),
+ gnu_actual = gnat_convert_internal (gnat_to_gnu_type (Etype (gnat_actual)),
gnu_actual);
}
@@ -1911,7 +1911,7 @@
&& TYPE_IS_PADDING_P (gnu_formal_type))
{
gnu_formal_type = TREE_TYPE (TYPE_FIELDS (gnu_formal_type));
- gnu_actual = convert (gnu_formal_type, gnu_actual);
+ gnu_actual = gnat_convert_internal (gnu_formal_type, gnu_actual);
}
/* Take the address of the object and convert to the proper pointer
@@ -1920,7 +1920,7 @@
possibility that the ARRAY_REF might return a constant and we'd be
getting the wrong address. Neither approach is exactly correct,
but this is the most likely to work in all cases. */
- gnu_actual = convert (gnu_formal_type,
+ gnu_actual = gnat_convert_internal (gnu_formal_type,
build_unary_op (ADDR_EXPR, NULL_TREE,
gnu_actual));
}
@@ -1931,7 +1931,7 @@
if ((TREE_CODE (gnu_actual) == INDIRECT_REF
|| TREE_CODE (gnu_actual) == UNCONSTRAINED_ARRAY_REF)
&& TREE_PRIVATE (gnu_actual))
- gnu_actual = convert (DECL_ARG_TYPE (get_gnu_tree (gnat_formal)),
+ gnu_actual = gnat_convert_internal (DECL_ARG_TYPE (get_gnu_tree (gnat_formal)),
integer_zero_node);
else
gnu_actual = build_unary_op (ADDR_EXPR, NULL_TREE,
@@ -1957,13 +1957,13 @@
BITS_PER_WORD))
gnu_actual
= unchecked_convert (DECL_ARG_TYPE (gnu_formal),
- convert (gnat_type_for_size
+ gnat_convert_internal (gnat_type_for_size
(tree_low_cst (gnu_actual_size, 1),
1),
integer_zero_node),
false);
else
- gnu_actual = convert (DECL_ARG_TYPE (gnu_formal), gnu_actual);
+ gnu_actual = gnat_convert_internal (DECL_ARG_TYPE (gnu_formal), gnu_actual);
}
gnu_actual_list = tree_cons (NULL_TREE, gnu_actual, gnu_actual_list);
@@ -2070,7 +2070,7 @@
/* If the result is a padded type, remove the padding. */
if (TREE_CODE (TREE_TYPE (gnu_result)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_result)))
- gnu_result = convert (TREE_TYPE (TYPE_FIELDS
+ gnu_result = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS
(TREE_TYPE (gnu_result))),
gnu_result);
@@ -2095,7 +2095,7 @@
if (!(!TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (gnu_actual)))
&& TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (gnu_result)))))
- gnu_result = convert (TREE_TYPE (gnu_actual), gnu_result);
+ gnu_result = gnat_convert_internal (TREE_TYPE (gnu_actual), gnu_result);
}
gnu_result = build_binary_op (MODIFY_EXPR, NULL_TREE,
@@ -2335,7 +2335,7 @@
this_choice
= build_binary_op
(EQ_EXPR, integer_type_node,
- convert
+ gnat_convert_internal
(integer_type_node,
build_component_ref
(build_unary_op
@@ -2362,7 +2362,7 @@
this_choice
= build_binary_op
(EQ_EXPR, integer_type_node, TREE_VALUE (gnu_except_ptr_stack),
- convert (TREE_TYPE (TREE_VALUE (gnu_except_ptr_stack)),
+ gnat_convert_internal (TREE_TYPE (TREE_VALUE (gnu_except_ptr_stack)),
build_unary_op (ADDR_EXPR, NULL_TREE, gnu_expr)));
/* If this is the distinguished exception "Non_Ada_Error" (and we are
@@ -2720,7 +2720,7 @@
convert it to a machine number if it isn't already. That
forces BASE to 0 or 2 and simplifies the rest of our logic. */
if (UR_Is_Zero (ur_realval))
- gnu_result = convert (gnu_result_type, integer_zero_node);
+ gnu_result = gnat_convert_internal (gnu_result_type, integer_zero_node);
else
{
if (!Is_Machine_Number (gnat_node))
@@ -2942,7 +2942,7 @@
if (TREE_CODE (TREE_TYPE (gnu_array_object)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_array_object)))
gnu_array_object
- = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_array_object))),
+ = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_array_object))),
gnu_array_object);
gnu_result = gnu_array_object;
@@ -3033,8 +3033,8 @@
/* Build a compound expression that does the range checks */
gnu_expr
= build_binary_op (COMPOUND_EXPR, gnu_expr_type,
- convert (gnu_expr_type, gnu_expr_h),
- convert (gnu_expr_type, gnu_expr_l));
+ gnat_convert_internal (gnu_expr_type, gnu_expr_h),
+ gnat_convert_internal (gnu_expr_type, gnu_expr_l));
/* Build a conditional expression that returns the range checks
expression if the slice range is not null (max >= min) or
@@ -3042,9 +3042,9 @@
gnu_expr
= fold (build3 (COND_EXPR, gnu_expr_type,
build_binary_op (GE_EXPR, gnu_expr_type,
- convert (gnu_expr_type,
+ gnat_convert_internal (gnu_expr_type,
gnu_max_expr),
- convert (gnu_expr_type,
+ gnat_convert_internal (gnu_expr_type,
gnu_min_expr)),
gnu_expr, gnu_min_expr));
}
@@ -3188,7 +3188,7 @@
else
gcc_unreachable ();
- gnu_result = convert (gnu_result_type, gnu_result);
+ gnu_result = gnat_convert_internal (gnu_result_type, gnu_result);
}
break;
@@ -3360,7 +3360,7 @@
{
tree gnu_count_type = get_base_type (TREE_TYPE (gnu_rhs));
tree gnu_max_shift
- = convert (gnu_count_type, TYPE_SIZE (gnu_type));
+ = gnat_convert_internal (gnu_count_type, TYPE_SIZE (gnu_type));
if (Nkind (gnat_node) == N_Op_Rotate_Left
|| Nkind (gnat_node) == N_Op_Rotate_Right)
@@ -3373,7 +3373,7 @@
build_binary_op (MINUS_EXPR,
gnu_count_type,
gnu_max_shift,
- convert (gnu_count_type,
+ gnat_convert_internal (gnu_count_type,
integer_one_node)),
gnu_rhs);
}
@@ -3389,8 +3389,8 @@
if (gnu_type != gnu_result_type)
{
- gnu_lhs = convert (gnu_type, gnu_lhs);
- gnu_rhs = convert (gnu_type, gnu_rhs);
+ gnu_lhs = gnat_convert_internal (gnu_type, gnu_lhs);
+ gnu_rhs = gnat_convert_internal (gnu_type, gnu_rhs);
}
gnu_result = build_binary_op (code, gnu_type, gnu_lhs, gnu_rhs);
@@ -3406,9 +3406,9 @@
(gnu_type,
build_binary_op (GE_EXPR, integer_type_node,
gnu_rhs,
- convert (TREE_TYPE (gnu_rhs),
+ gnat_convert_internal (TREE_TYPE (gnu_rhs),
TYPE_SIZE (gnu_type))),
- convert (gnu_type, integer_zero_node),
+ gnat_convert_internal (gnu_type, integer_zero_node),
gnu_result);
}
break;
@@ -3491,7 +3491,7 @@
|| Is_Constrained (gnat_desig_type))
{
gnu_type = gnat_to_gnu_type (gnat_desig_type);
- gnu_init = convert (gnu_type, gnu_init);
+ gnu_init = gnat_convert_internal (gnu_type, gnu_init);
}
else
{
@@ -3499,7 +3499,7 @@
if (TREE_CODE (gnu_type) == UNCONSTRAINED_ARRAY_TYPE)
gnu_type = TREE_TYPE (gnu_init);
- gnu_init = convert (gnu_type, gnu_init);
+ gnu_init = gnat_convert_internal (gnu_type, gnu_init);
}
}
else
@@ -4057,7 +4057,7 @@
by converting to a thin pointer. */
if (TYPE_FAT_POINTER_P (TREE_TYPE (gnu_ptr)))
gnu_ptr
- = convert (build_pointer_type
+ = gnat_convert_internal (build_pointer_type
(TYPE_OBJECT_RECORD_TYPE
(TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (gnu_ptr)))),
gnu_ptr);
@@ -4087,10 +4087,10 @@
tree gnu_char_ptr_type = build_pointer_type (char_type_node);
tree gnu_pos = byte_position (TYPE_FIELDS (gnu_obj_type));
tree gnu_byte_offset
- = convert (gnu_char_ptr_type,
+ = gnat_convert_internal (gnu_char_ptr_type,
size_diffop (size_zero_node, gnu_pos));
- gnu_ptr = convert (gnu_char_ptr_type, gnu_ptr);
+ gnu_ptr = gnat_convert_internal (gnu_char_ptr_type, gnu_ptr);
gnu_ptr = build_binary_op (MINUS_EXPR, gnu_char_ptr_type,
gnu_ptr, gnu_byte_offset);
}
@@ -4288,7 +4288,7 @@
&& CONTAINS_PLACEHOLDER_P (TYPE_SIZE
(TREE_TYPE (TYPE_FIELDS
(TREE_TYPE (gnu_result))))))
- gnu_result = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_result))),
+ gnu_result = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_result))),
gnu_result);
}
@@ -4310,7 +4310,7 @@
/* Remove any padding record, but do nothing more in this case. */
if (TREE_CODE (TREE_TYPE (gnu_result)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_result)))
- gnu_result = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_result))),
+ gnu_result = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_result))),
gnu_result);
}
@@ -4318,7 +4318,7 @@
|| gnu_result_type == void_type_node)
gnu_result = error_mark_node;
else if (gnu_result_type != TREE_TYPE (gnu_result))
- gnu_result = convert (gnu_result_type, gnu_result);
+ gnu_result = gnat_convert_internal (gnu_result_type, gnu_result);
/* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RESULT. */
while ((TREE_CODE (gnu_result) == NOP_EXPR
@@ -4440,7 +4440,7 @@
if (TREE_CODE (TREE_TYPE (gnu_decl)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (gnu_decl)))
gnu_lhs
- = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_decl))), gnu_decl);
+ = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (gnu_decl))), gnu_decl);
/* Otherwise, if this is going into memory and the initializer isn't
valid for the assembler and loader. Gimplification could do this,
@@ -4659,7 +4659,7 @@
dereference it. */
if (AGGREGATE_TYPE_P (TREE_TYPE (expr)))
*expr_p = build1 (INDIRECT_REF, TREE_TYPE (expr),
- convert (build_pointer_type (TREE_TYPE (expr)),
+ gnat_convert_internal (build_pointer_type (TREE_TYPE (expr)),
integer_zero_node));
else
{
@@ -5215,12 +5215,12 @@
(build_binary_op (TRUTH_ORIF_EXPR, integer_type_node,
invert_truthvalue
(build_binary_op (GE_EXPR, integer_type_node,
- convert (gnu_compare_type, gnu_expr),
- convert (gnu_compare_type, gnu_low))),
+ gnat_convert_internal (gnu_compare_type, gnu_expr),
+ gnat_convert_internal (gnu_compare_type, gnu_low))),
invert_truthvalue
(build_binary_op (LE_EXPR, integer_type_node,
- convert (gnu_compare_type, gnu_expr),
- convert (gnu_compare_type,
+ gnat_convert_internal (gnu_compare_type, gnu_expr),
+ gnat_convert_internal (gnu_compare_type,
gnu_high)))),
gnu_expr, CE_Range_Check_Failed);
}
@@ -5250,7 +5250,7 @@
/* Must do this computation in the base type in case the expression's
type is an unsigned subtypes. */
- gnu_expr_check = convert (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
+ gnu_expr_check = gnat_convert_internal (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
/* If GNU_LOW or GNU_HIGH are a PLACEHOLDER_EXPR, qualify them by
the object we are handling. */
@@ -5263,11 +5263,11 @@
(build_binary_op (TRUTH_ORIF_EXPR, integer_type_node,
build_binary_op (LT_EXPR, integer_type_node,
gnu_expr_check,
- convert (TREE_TYPE (gnu_expr_check),
+ gnat_convert_internal (TREE_TYPE (gnu_expr_check),
gnu_low)),
build_binary_op (GT_EXPR, integer_type_node,
gnu_expr_check,
- convert (TREE_TYPE (gnu_expr_check),
+ gnat_convert_internal (TREE_TYPE (gnu_expr_check),
gnu_high))),
gnu_expr, CE_Index_Check_Failed);
}
@@ -5331,7 +5331,7 @@
and simplifies code in all cases anyway. */
if (!rangep && !overflowp && INTEGRAL_TYPE_P (gnu_base_type)
&& !FLOAT_TYPE_P (gnu_in_type))
- return convert (gnu_type, gnu_expr);
+ return gnat_convert_internal (gnu_type, gnu_expr);
/* First convert the expression to its base type. This
will never generate code, but makes the tests below much simpler.
@@ -5339,7 +5339,7 @@
array type since then we need to get the bounds from the original
(unpacked) type. */
if (TREE_CODE (gnu_type) != UNCONSTRAINED_ARRAY_TYPE)
- gnu_result = convert (gnu_in_basetype, gnu_result);
+ gnu_result = gnat_convert_internal (gnu_in_basetype, gnu_result);
/* If overflow checks are requested, we need to be sure the result will
fit in the output base type. But don't do this if the input
@@ -5359,17 +5359,17 @@
comparing them properly. Likewise, convert the upper bounds
to unsigned types. */
if (INTEGRAL_TYPE_P (gnu_in_basetype) && TYPE_UNSIGNED (gnu_in_basetype))
- gnu_in_lb = convert (gnat_signed_type (gnu_in_basetype), gnu_in_lb);
+ gnu_in_lb = gnat_convert_internal (gnat_signed_type (gnu_in_basetype), gnu_in_lb);
if (INTEGRAL_TYPE_P (gnu_in_basetype)
&& !TYPE_UNSIGNED (gnu_in_basetype))
- gnu_in_ub = convert (gnat_unsigned_type (gnu_in_basetype), gnu_in_ub);
+ gnu_in_ub = gnat_convert_internal (gnat_unsigned_type (gnu_in_basetype), gnu_in_ub);
if (INTEGRAL_TYPE_P (gnu_base_type) && TYPE_UNSIGNED (gnu_base_type))
- gnu_out_lb = convert (gnat_signed_type (gnu_base_type), gnu_out_lb);
+ gnu_out_lb = gnat_convert_internal (gnat_signed_type (gnu_base_type), gnu_out_lb);
if (INTEGRAL_TYPE_P (gnu_base_type) && !TYPE_UNSIGNED (gnu_base_type))
- gnu_out_ub = convert (gnat_unsigned_type (gnu_base_type), gnu_out_ub);
+ gnu_out_ub = gnat_convert_internal (gnat_unsigned_type (gnu_base_type), gnu_out_ub);
/* Check each bound separately and only if the result bound
is tighter than the bound on the input type. Note that all the
@@ -5390,7 +5390,7 @@
gnu_cond
= invert_truthvalue
(build_binary_op (GE_EXPR, integer_type_node,
- gnu_input, convert (gnu_in_basetype,
+ gnu_input, gnat_convert_internal (gnu_in_basetype,
gnu_out_lb)));
if (INTEGRAL_TYPE_P (gnu_in_basetype)
@@ -5404,7 +5404,7 @@
invert_truthvalue
(build_binary_op (LE_EXPR, integer_type_node,
gnu_input,
- convert (gnu_in_basetype,
+ gnat_convert_internal (gnu_in_basetype,
gnu_out_ub))));
if (!integer_zerop (gnu_cond))
@@ -5460,9 +5460,9 @@
conversion of the input to the calc_type (if necessary).
*/
- gnu_zero = convert (gnu_in_basetype, integer_zero_node);
+ gnu_zero = gnat_convert_internal (gnu_in_basetype, integer_zero_node);
gnu_saved_result = save_expr (gnu_result);
- gnu_conv = convert (calc_type, gnu_saved_result);
+ gnu_conv = gnat_convert_internal (calc_type, gnu_saved_result);
gnu_comp = build2 (GE_EXPR, integer_type_node,
gnu_saved_result, gnu_zero);
gnu_add_pred_half
@@ -5478,7 +5478,7 @@
&& TREE_CODE (gnu_result) == UNCONSTRAINED_ARRAY_REF)
gnu_result = unchecked_convert (gnu_base_type, gnu_result, false);
else
- gnu_result = convert (gnu_base_type, gnu_result);
+ gnu_result = gnat_convert_internal (gnu_base_type, gnu_result);
/* Finally, do the range check if requested. Note that if the
result type is a modular type, the range check is actually
@@ -5489,7 +5489,7 @@
&& TYPE_MODULAR_P (gnu_base_type) && overflowp))
gnu_result = emit_range_check (gnu_result, gnat_type);
- return convert (gnu_type, gnu_result);
+ return gnat_convert_internal (gnu_type, gnu_result);
}
/* Return 1 if GNU_EXPR can be directly addressed. This is the case unless
@@ -5695,7 +5695,7 @@
if (Do_Range_Check (Expression (gnat_assoc)))
gnu_expr = emit_range_check (gnu_expr, Etype (gnat_field));
- gnu_expr = convert (TREE_TYPE (gnu_field), gnu_expr);
+ gnu_expr = gnat_convert_internal (TREE_TYPE (gnu_field), gnu_expr);
/* Add the field and expression to the list. */
gnu_list = tree_cons (gnu_field, gnu_expr, gnu_list);
@@ -5753,7 +5753,7 @@
}
gnu_expr_list
- = tree_cons (gnu_index, convert (TREE_TYPE (gnu_array_type), gnu_expr),
+ = tree_cons (gnu_index, gnat_convert_internal (TREE_TYPE (gnu_array_type), gnu_expr),
gnu_expr_list);
gnu_index = int_const_binop (PLUS_EXPR, gnu_index, integer_one_node, 0);
@@ -5798,7 +5798,7 @@
for (tem = values; tem; tem = TREE_CHAIN (tem))
if (DECL_NAME (TREE_PURPOSE (tem)) == DECL_NAME (field))
{
- value = convert (TREE_TYPE (field), TREE_VALUE (tem));
+ value = gnat_convert_internal (TREE_TYPE (field), TREE_VALUE (tem));
TREE_ADDRESSABLE (tem) = 1;
}
@@ -5825,7 +5825,7 @@
/* If we got a padded type, remove it too. */
if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (exp)))
- exp = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp))), exp);
+ exp = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp))), exp);
return exp;
}
Index: gcc/ada/utils.c
===================================================================
--- gcc/ada/utils.c (revision 112530)
+++ gcc/ada/utils.c (working copy)
@@ -803,7 +803,7 @@
{
tree size_unit
= (had_size_unit ? TYPE_SIZE_UNIT (record_type)
- : convert (sizetype, size_binop (CEIL_DIV_EXPR, size,
+ :gnat_convert_internal (sizetype, size_binop (CEIL_DIV_EXPR, size,
bitsize_unit_node)));
TYPE_SIZE (record_type)
@@ -1069,12 +1069,12 @@
the effort. */
STRIP_NOPS (in);
- *pvar = convert (bitsizetype, in);
+ *pvar =gnat_convert_internal (bitsizetype, in);
if (TREE_CODE (in) == INTEGER_CST)
{
*pvar = bitsize_zero_node;
- return convert (bitsizetype, in);
+ return gnat_convert_internal (bitsizetype, in);
}
else if (TREE_CODE (in) == PLUS_EXPR || TREE_CODE (in) == MINUS_EXPR)
{
@@ -1361,7 +1361,7 @@
creation below, which is typically required when no position has been
specified. */
if (size)
- size = convert (bitsizetype, size);
+ size =gnat_convert_internal (bitsizetype, size);
else if (packed == 1)
{
size = rm_size (field_type);
@@ -2119,8 +2119,8 @@
else
gcc_unreachable ();
- min = convert (TREE_TYPE (TREE_CHAIN (field)), TYPE_MIN_VALUE (bounds));
- max = convert (TREE_TYPE (field), TYPE_MAX_VALUE (bounds));
+ min =gnat_convert_internal (TREE_TYPE (TREE_CHAIN (field)), TYPE_MIN_VALUE (bounds));
+ max =gnat_convert_internal (TREE_TYPE (field), TYPE_MAX_VALUE (bounds));
/* If either MIN or MAX involve a PLACEHOLDER_EXPR, we must
substitute it from OBJECT. */
@@ -2358,7 +2358,7 @@
for (i = 0, inner_type = type; i < ndim;
i++, inner_type = TREE_TYPE (inner_type))
tem = build4 (ARRAY_REF, TREE_TYPE (inner_type), tem,
- convert (TYPE_DOMAIN (inner_type), size_zero_node),
+ gnat_convert_internal (TYPE_DOMAIN (inner_type), size_zero_node),
NULL_TREE, NULL_TREE);
field_list
@@ -2647,9 +2647,9 @@
gnat_build_constructor
(type,
tree_cons (TYPE_FIELDS (type),
- convert (TREE_TYPE (TYPE_FIELDS (type)), expr),
+ gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (type)), expr),
tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
- convert (build_pointer_type (template_type),
+ gnat_convert_internal (build_pointer_type (template_type),
expr),
NULL_TREE)));
@@ -2691,7 +2691,7 @@
return
gnat_build_constructor
(type, tree_cons (TYPE_FIELDS (type),
- convert (TREE_TYPE (TYPE_FIELDS (type)), expr),
+ gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (type)), expr),
tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
template_addr, NULL_TREE)));
}
@@ -2723,8 +2723,9 @@
conversions; callers should filter out those that are
not permitted by the language being compiled. */
+
tree
-convert (tree type, tree expr)
+gnat_convert_internal (tree type, tree expr)
{
enum tree_code code = TREE_CODE (type);
tree etype = TREE_TYPE (expr);
@@ -2753,7 +2754,7 @@
== TYPE_FIELDS (etype))
return VEC_index (constructor_elt, CONSTRUCTOR_ELTS (expr), 0)->value;
else
- return convert (type,
+ return gnat_convert_internal (type,
build_component_ref (expr, NULL_TREE,
TYPE_FIELDS (etype), false));
}
@@ -2773,7 +2774,7 @@
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE
&& TYPE_IS_PADDING_P (TREE_TYPE (TREE_OPERAND (expr, 0)))
&& !TREE_CONSTANT (TYPE_SIZE (type)))
- return convert (type, TREE_OPERAND (expr, 0));
+ return gnat_convert_internal (type, TREE_OPERAND (expr, 0));
/* If the result type is a padded type with a self-referentially-sized
field and the expression type is a record, do this as an
@@ -2786,7 +2787,7 @@
return
gnat_build_constructor (type,
tree_cons (TYPE_FIELDS (type),
- convert (TREE_TYPE
+ gnat_convert_internal (TREE_TYPE
(TYPE_FIELDS (type)),
expr),
NULL_TREE));
@@ -2794,7 +2795,7 @@
/* If the input is a biased type, adjust first. */
if (ecode == INTEGER_TYPE && TYPE_BIASED_REPRESENTATION_P (etype))
- return convert (type, fold (build2 (PLUS_EXPR, TREE_TYPE (etype),
+ return gnat_convert_internal (type, fold (build2 (PLUS_EXPR, TREE_TYPE (etype),
fold_convert (TREE_TYPE (etype),
expr),
TYPE_MIN_VALUE (etype))));
@@ -2808,7 +2809,7 @@
if (ecode == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (etype)
&& code != UNCONSTRAINED_ARRAY_TYPE
&& TYPE_MAIN_VARIANT (type) != TYPE_MAIN_VARIANT (etype))
- return convert (type, build_component_ref (expr, NULL_TREE,
+ return gnat_convert_internal (type, build_component_ref (expr, NULL_TREE,
TYPE_FIELDS (etype), false));
/* If converting to a type that contains a template, convert to the data
@@ -2829,7 +2830,7 @@
build_template (TREE_TYPE (TYPE_FIELDS (type)),
obj_type, NULL_TREE),
tree_cons (TREE_CHAIN (TYPE_FIELDS (type)),
- convert (obj_type, expr), NULL_TREE)));
+ gnat_convert_internal (obj_type, expr), NULL_TREE)));
}
/* There are some special cases of expressions that we process
@@ -2901,7 +2902,7 @@
one of the types is a fat pointer, which is handled by
specialized code below which relies on exact type matching. */
else if (!TYPE_FAT_POINTER_P (type) && !TYPE_FAT_POINTER_P (etype))
- return convert (type, op0);
+ return gnat_convert_internal (type, op0);
}
}
break;
@@ -2921,7 +2922,7 @@
|| TREE_CODE (etype) == UNION_TYPE)
&& !TYPE_FAT_POINTER_P (type) && !TYPE_FAT_POINTER_P (etype))
return build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (build_pointer_type (type),
+ gnat_convert_internal (build_pointer_type (type),
TREE_OPERAND (expr, 0)));
break;
@@ -2961,7 +2962,7 @@
else if (TYPE_BIASED_REPRESENTATION_P (type))
return fold_convert (type,
fold_build2 (MINUS_EXPR, TREE_TYPE (type),
- convert (TREE_TYPE (type), expr),
+ gnat_convert_internal (TREE_TYPE (type), expr),
TYPE_MIN_VALUE (type)));
/* ... fall through ... */
@@ -3012,7 +3013,7 @@
return
gnat_build_constructor
(type, tree_cons (TYPE_FIELDS (type),
- convert (TREE_TYPE (TYPE_FIELDS (type)), expr),
+ gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (type)), expr),
NULL_TREE));
/* ... fall through ... */
@@ -3051,7 +3052,7 @@
else if (ecode == UNCONSTRAINED_ARRAY_TYPE)
return
build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (TREE_TYPE (type),
+ gnat_convert_internal (TREE_TYPE (type),
build_unary_op (ADDR_EXPR,
NULL_TREE, expr)));
else
@@ -3064,6 +3065,7 @@
gcc_unreachable ();
}
}
+
/* Remove all conversions that are done in EXP. This includes converting
from a padded type or to a justified modular type. If TRUE_ADDRESS
@@ -3137,7 +3139,7 @@
it contains a template. */
if (TYPE_IS_PADDING_P (TREE_TYPE (exp)))
{
- new = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp))), exp);
+ new =gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (exp))), exp);
if (TREE_CODE (TREE_TYPE (new)) == RECORD_TYPE
&& TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (new)))
return
@@ -3206,7 +3208,7 @@
TYPE_MAIN_VARIANT (rtype) = rtype;
}
- expr = convert (rtype, expr);
+ expr =gnat_convert_internal (rtype, expr);
if (type != rtype)
expr = build1 (NOP_EXPR, type, expr);
}
@@ -3290,16 +3292,16 @@
tree base_type = gnat_type_for_mode (TYPE_MODE (type),
TYPE_UNSIGNED (type));
tree shift_expr
- = convert (base_type,
+ =gnat_convert_internal (base_type,
size_binop (MINUS_EXPR,
bitsize_int
(GET_MODE_BITSIZE (TYPE_MODE (type))),
TYPE_RM_SIZE (type)));
expr
- = convert (type,
+ =gnat_convert_internal (type,
build_binary_op (RSHIFT_EXPR, base_type,
build_binary_op (LSHIFT_EXPR, base_type,
- convert (base_type, expr),
+ gnat_convert_internal (base_type, expr),
shift_expr),
shift_expr));
}
Index: gcc/ada/decl.c
===================================================================
--- gcc/ada/decl.c (revision 112530)
+++ gcc/ada/decl.c (working copy)
@@ -721,7 +721,7 @@
&& TYPE_IS_PADDING_P (gnu_type)
&& (CONTAINS_PLACEHOLDER_P
(TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type)))))))
- gnu_expr = convert (gnu_type, gnu_expr);
+ gnu_expr = gnat_convert_internal (gnu_type, gnu_expr);
/* See if this is a renaming, and handle appropriately depending on
what is renamed and in which context. There are three major
@@ -930,7 +930,7 @@
above. */
gnu_size = NULL_TREE;
gnu_type = build_reference_type (gnu_type);
- gnu_address = convert (gnu_type, gnu_address);
+ gnu_address = gnat_convert_internal (gnu_type, gnu_address);
used_by_ref = true;
const_flag = !Is_Public (gnat_entity);
@@ -1099,7 +1099,7 @@
&& TYPE_IS_PADDING_P (gnu_type)
&& (CONTAINS_PLACEHOLDER_P
(TYPE_SIZE (TREE_TYPE (TYPE_FIELDS (gnu_type)))))))
- gnu_expr = convert (gnu_type, gnu_expr);
+ gnu_expr = gnat_convert_internal (gnu_type, gnu_expr);
/* If this name is external or there was a name specified, use it,
unless this is a VMS exception object since this would conflict
@@ -1310,7 +1310,7 @@
TYPE_MODULAR_P (gnu_type) = 1;
SET_TYPE_MODULUS (gnu_type, gnu_modulus);
gnu_high = fold (build2 (MINUS_EXPR, gnu_type, gnu_modulus,
- convert (gnu_type, integer_one_node)));
+ gnat_convert_internal (gnu_type, integer_one_node)));
}
/* If we have to set TYPE_PRECISION different from its natural value,
@@ -1380,14 +1380,14 @@
TREE_TYPE (gnu_type) = get_unpadded_type (Etype (gnat_entity));
TYPE_MIN_VALUE (gnu_type)
- = convert (TREE_TYPE (gnu_type),
+ = gnat_convert_internal (TREE_TYPE (gnu_type),
elaborate_expression (Type_Low_Bound (gnat_entity),
gnat_entity,
get_identifier ("L"), definition, 1,
Needs_Debug_Info (gnat_entity)));
TYPE_MAX_VALUE (gnu_type)
- = convert (TREE_TYPE (gnu_type),
+ = gnat_convert_internal (TREE_TYPE (gnu_type),
elaborate_expression (Type_High_Bound (gnat_entity),
gnat_entity,
get_identifier ("U"), definition, 1,
@@ -1501,14 +1501,14 @@
TYPE_PRECISION (gnu_type) = fp_size_to_prec (esize);
TYPE_MIN_VALUE (gnu_type)
- = convert (TREE_TYPE (gnu_type),
+ = gnat_convert_internal (TREE_TYPE (gnu_type),
elaborate_expression (Type_Low_Bound (gnat_entity),
gnat_entity, get_identifier ("L"),
definition, 1,
Needs_Debug_Info (gnat_entity)));
TYPE_MAX_VALUE (gnu_type)
- = convert (TREE_TYPE (gnu_type),
+ = gnat_convert_internal (TREE_TYPE (gnu_type),
elaborate_expression (Type_High_Bound (gnat_entity),
gnat_entity, get_identifier ("U"),
definition, 1,
@@ -1620,9 +1620,9 @@
tree gnu_base_subtype
= get_unpadded_type (Etype (gnat_ind_base_subtype));
tree gnu_base_min
- = convert (sizetype, TYPE_MIN_VALUE (gnu_base_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MIN_VALUE (gnu_base_subtype));
tree gnu_base_max
- = convert (sizetype, TYPE_MAX_VALUE (gnu_base_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MAX_VALUE (gnu_base_subtype));
tree gnu_min_field, gnu_max_field, gnu_min, gnu_max;
/* Make the FIELD_DECLs for the minimum and maximum of this
@@ -1656,8 +1656,8 @@
/* Make a range type with the new ranges, but using
the Ada subtype. Then we convert to sizetype. */
gnu_index_types[index]
- = create_index_type (convert (sizetype, gnu_min),
- convert (sizetype, gnu_max),
+ = create_index_type (gnat_convert_internal (sizetype, gnu_min),
+ gnat_convert_internal (sizetype, gnu_max),
build_range_type (gnu_ind_subtype,
gnu_min, gnu_max));
/* Update the maximum size of the array, in elements. */
@@ -1724,7 +1724,7 @@
TYPE_SIZE_UNIT (tem)));
gnu_max_size = size_binop (MAX_EXPR, bitsize_zero_node,
size_binop (MULT_EXPR,
- convert (bitsizetype,
+ gnat_convert_internal (bitsizetype,
gnu_max_size),
TYPE_SIZE (tem)));
@@ -1859,20 +1859,20 @@
tree gnu_index_subtype
= get_unpadded_type (Etype (gnat_ind_subtype));
tree gnu_min
- = convert (sizetype, TYPE_MIN_VALUE (gnu_index_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MIN_VALUE (gnu_index_subtype));
tree gnu_max
- = convert (sizetype, TYPE_MAX_VALUE (gnu_index_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MAX_VALUE (gnu_index_subtype));
tree gnu_base_subtype
= get_unpadded_type (Etype (gnat_ind_base_subtype));
tree gnu_base_min
- = convert (sizetype, TYPE_MIN_VALUE (gnu_base_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MIN_VALUE (gnu_base_subtype));
tree gnu_base_max
- = convert (sizetype, TYPE_MAX_VALUE (gnu_base_subtype));
+ = gnat_convert_internal (sizetype, TYPE_MAX_VALUE (gnu_base_subtype));
tree gnu_base_type = get_base_type (gnu_base_subtype);
tree gnu_base_base_min
- = convert (sizetype, TYPE_MIN_VALUE (gnu_base_type));
+ = gnat_convert_internal (sizetype, TYPE_MIN_VALUE (gnu_base_type));
tree gnu_base_base_max
- = convert (sizetype, TYPE_MAX_VALUE (gnu_base_type));
+ = gnat_convert_internal (sizetype, TYPE_MAX_VALUE (gnu_base_type));
tree gnu_high;
tree gnu_this_max;
@@ -2046,7 +2046,7 @@
gnu_max_size_unit = size_binop (MULT_EXPR, gnu_max_size,
TYPE_SIZE_UNIT (gnu_type));
gnu_max_size = size_binop (MULT_EXPR,
- convert (bitsizetype, gnu_max_size),
+ gnat_convert_internal (bitsizetype, gnu_max_size),
TYPE_SIZE (gnu_type));
for (index = array_dim - 1; index >= 0; index --)
@@ -2275,21 +2275,21 @@
= get_base_type (TREE_TYPE (TYPE_INDEX_TYPE
(TYPE_DOMAIN (gnu_string_array_type))));
tree gnu_lower_bound
- = convert (gnu_string_index_type,
+ = gnat_convert_internal (gnu_string_index_type,
gnat_to_gnu (String_Literal_Low_Bound (gnat_entity)));
int length = UI_To_Int (String_Literal_Length (gnat_entity));
tree gnu_length = ssize_int (length - 1);
tree gnu_upper_bound
= build_binary_op (PLUS_EXPR, gnu_string_index_type,
gnu_lower_bound,
- convert (gnu_string_index_type, gnu_length));
+ gnat_convert_internal (gnu_string_index_type, gnu_length));
tree gnu_range_type
= build_range_type (gnu_string_index_type,
gnu_lower_bound, gnu_upper_bound);
tree gnu_index_type
- = create_index_type (convert (sizetype,
+ = create_index_type (gnat_convert_internal (sizetype,
TYPE_MIN_VALUE (gnu_range_type)),
- convert (sizetype,
+ gnat_convert_internal (sizetype,
TYPE_MAX_VALUE (gnu_range_type)),
gnu_range_type);
@@ -2743,7 +2743,7 @@
SET_DECL_OFFSET_ALIGN (gnu_field, offset_align);
DECL_SIZE (gnu_field) = gnu_size;
DECL_SIZE_UNIT (gnu_field)
- = convert (sizetype,
+ = gnat_convert_internal (sizetype,
size_binop (CEIL_DIV_EXPR, gnu_size,
bitsize_unit_node));
layout_decl (gnu_field, DECL_OFFSET_ALIGN (gnu_field));
@@ -3792,7 +3792,7 @@
gnu_type = build_reference_type (gnu_type);
if (gnu_address)
- gnu_address = convert (gnu_type, gnu_address);
+ gnu_address = gnat_convert_internal (gnu_type, gnu_address);
gnu_decl
= create_var_decl (gnu_entity_id, gnu_ext_name, gnu_type,
@@ -4815,7 +4815,7 @@
{
tree record_type = make_node (RECORD_TYPE);
tree place = build0 (PLACEHOLDER_EXPR, record_type);
- tree size_addr_place = convert (sizetype,
+ tree size_addr_place = gnat_convert_internal (sizetype,
build_unary_op (ADDR_EXPR, NULL_TREE,
place));
tree name = TYPE_NAME (type);
@@ -4830,7 +4830,7 @@
with the two's complement of the address and multiplying
by the number of bits per unit. Do all this in sizetype. */
pos = size_binop (MULT_EXPR,
- convert (bitsizetype,
+ gnat_convert_internal (bitsizetype,
size_binop (BIT_AND_EXPR,
size_diffop (size_zero_node,
size_addr_place),
@@ -4850,7 +4850,7 @@
TYPE_ALIGN (record_type) = BIGGEST_ALIGNMENT;
TYPE_SIZE (record_type)
= size_binop (PLUS_EXPR,
- size_binop (MULT_EXPR, convert (bitsizetype, size),
+ size_binop (MULT_EXPR, gnat_convert_internal (bitsizetype, size),
bitsize_unit_node),
bitsize_int (align));
TYPE_SIZE_UNIT (record_type)
@@ -5036,7 +5036,7 @@
DECL_INTERNAL_P (field) = 1;
TYPE_SIZE (record) = size ? size : orig_size;
TYPE_SIZE_UNIT (record)
- = (size ? convert (sizetype,
+ = (size ? gnat_convert_internal (sizetype,
size_binop (CEIL_DIV_EXPR, size, bitsize_unit_node))
: TYPE_SIZE_UNIT (type));
@@ -5865,7 +5865,7 @@
/* This may have come from a conversion from some smaller type,
so ensure this is in bitsizetype. */
- gnu_size = convert (bitsizetype, gnu_size);
+ gnu_size = gnat_convert_internal (bitsizetype, gnu_size);
/* For negative values, use NEGATE_EXPR of the supplied value. */
if (tree_int_cst_sgn (gnu_size) < 0)
@@ -6326,9 +6326,9 @@
= unsigned_p ? make_unsigned_type (size) : make_signed_type (size);
TREE_TYPE (new_type) = TREE_TYPE (type) ? TREE_TYPE (type) : type;
TYPE_MIN_VALUE (new_type)
- = convert (TREE_TYPE (new_type), TYPE_MIN_VALUE (type));
+ = gnat_convert_internal (TREE_TYPE (new_type), TYPE_MIN_VALUE (type));
TYPE_MAX_VALUE (new_type)
- = convert (TREE_TYPE (new_type), TYPE_MAX_VALUE (type));
+ = gnat_convert_internal (TREE_TYPE (new_type), TYPE_MAX_VALUE (type));
TYPE_BIASED_REPRESENTATION_P (new_type) = biased_p;
TYPE_RM_SIZE_NUM (new_type) = bitsize_int (size);
return new_type;
Index: gcc/ada/utils2.c
===================================================================
--- gcc/ada/utils2.c (revision 112530)
+++ gcc/ada/utils2.c (working copy)
@@ -87,12 +87,12 @@
return expr;
case INTEGER_CST:
- return (integer_zerop (expr) ? convert (type, integer_zero_node)
- : convert (type, integer_one_node));
+ return (integer_zerop (expr) ? gnat_convert_internal (type, integer_zero_node)
+ : gnat_convert_internal (type, integer_one_node));
case REAL_CST:
- return (real_zerop (expr) ? convert (type, integer_zero_node)
- : convert (type, integer_one_node));
+ return (real_zerop (expr) ? gnat_convert_internal (type, integer_zero_node)
+ : gnat_convert_internal (type, integer_one_node));
case COND_EXPR:
/* Distribute the conversion into the arms of a COND_EXPR. */
@@ -103,7 +103,7 @@
default:
return build_binary_op (NE_EXPR, type, expr,
- convert (type, integer_zero_node));
+ gnat_convert_internal (type, integer_zero_node));
}
}
@@ -336,9 +336,9 @@
{
tree t1 = TREE_TYPE (a1);
tree t2 = TREE_TYPE (a2);
- tree result = convert (result_type, integer_one_node);
- tree a1_is_null = convert (result_type, integer_zero_node);
- tree a2_is_null = convert (result_type, integer_zero_node);
+ tree result = gnat_convert_internal (result_type, integer_one_node);
+ tree a1_is_null = gnat_convert_internal (result_type, integer_zero_node);
+ tree a2_is_null = gnat_convert_internal (result_type, integer_zero_node);
bool length_zero_p = false;
/* Process each dimension separately and compare the lengths. If any
@@ -362,7 +362,7 @@
Note that we have set the `length' values to the length - 1. */
if (TREE_CODE (length1) == INTEGER_CST
&& !integer_zerop (fold (build2 (PLUS_EXPR, bt, length2,
- convert (bt, integer_one_node)))))
+ gnat_convert_internal (bt, integer_one_node)))))
{
tem = a1, a1 = a2, a2 = tem;
tem = t1, t1 = t2, t2 = tem;
@@ -376,7 +376,7 @@
zero, we can just go inside the original bounds for the first
array and see if last < first. */
if (integer_zerop (fold (build2 (PLUS_EXPR, bt, length2,
- convert (bt, integer_one_node)))))
+ gnat_convert_internal (bt, integer_one_node)))))
{
tree ub = TYPE_MAX_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
tree lb = TYPE_MIN_VALUE (TYPE_INDEX_TYPE (TYPE_DOMAIN (t1)));
@@ -387,7 +387,7 @@
length_zero_p = true;
this_a1_is_null = comparison;
- this_a2_is_null = convert (result_type, integer_one_node);
+ this_a2_is_null = gnat_convert_internal (result_type, integer_one_node);
}
/* If the length is some other constant value, we know that the
@@ -413,7 +413,7 @@
length1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (length1, a1);
this_a1_is_null = build_binary_op (LT_EXPR, result_type, ub1, lb1);
- this_a2_is_null = convert (result_type, integer_zero_node);
+ this_a2_is_null = gnat_convert_internal (result_type, integer_zero_node);
}
/* Otherwise compare the computed lengths. */
@@ -427,10 +427,10 @@
this_a1_is_null
= build_binary_op (LT_EXPR, result_type, length1,
- convert (bt, integer_zero_node));
+ gnat_convert_internal (bt, integer_zero_node));
this_a2_is_null
= build_binary_op (LT_EXPR, result_type, length2,
- convert (bt, integer_zero_node));
+ gnat_convert_internal (bt, integer_zero_node));
}
result = build_binary_op (TRUTH_ANDIF_EXPR, result_type,
@@ -452,7 +452,7 @@
tree type = find_common_type (TREE_TYPE (a1), TREE_TYPE (a2));
if (type)
- a1 = convert (type, a1), a2 = convert (type, a2);
+ a1 = gnat_convert_internal (type, a1), a2 = gnat_convert_internal (type, a2);
result = build_binary_op (TRUTH_ANDIF_EXPR, result_type, result,
fold (build2 (EQ_EXPR, result_type, a1, a2)));
@@ -520,11 +520,11 @@
{
/* Copy the node so we ensure it can be modified to make it modular. */
op_type = copy_node (gnat_type_for_size (precision, unsignedp));
- modulus = convert (op_type, modulus);
+ modulus = gnat_convert_internal (op_type, modulus);
SET_TYPE_MODULUS (op_type, modulus);
TYPE_MODULAR_P (op_type) = 1;
- lhs = convert (op_type, lhs);
- rhs = convert (op_type, rhs);
+ lhs = gnat_convert_internal (op_type, lhs);
+ rhs = gnat_convert_internal (op_type, rhs);
}
/* Do the operation, then we'll fix it up. */
@@ -536,12 +536,12 @@
if (op_code == MULT_EXPR)
{
tree div_type = copy_node (gnat_type_for_size (needed_precision, 1));
- modulus = convert (div_type, modulus);
+ modulus = gnat_convert_internal (div_type, modulus);
SET_TYPE_MODULUS (div_type, modulus);
TYPE_MODULAR_P (div_type) = 1;
- result = convert (op_type,
+ result = gnat_convert_internal (op_type,
fold (build2 (TRUNC_MOD_EXPR, div_type,
- convert (div_type, result), modulus)));
+ gnat_convert_internal (div_type, result), modulus)));
}
/* For subtraction, add the modulus back if we are negative. */
@@ -550,7 +550,7 @@
result = save_expr (result);
result = fold (build3 (COND_EXPR, op_type,
build2 (LT_EXPR, integer_type_node, result,
- convert (op_type, integer_zero_node)),
+ gnat_convert_internal (op_type, integer_zero_node)),
fold (build2 (PLUS_EXPR, op_type,
result, modulus)),
result));
@@ -568,7 +568,7 @@
result));
}
- return convert (type, result);
+ return gnat_convert_internal (type, result);
}
/* Make a binary operation of kind OP_CODE. RESULT_TYPE is the type
@@ -710,7 +710,7 @@
if (operation_type != right_type
&& (!CONTAINS_PLACEHOLDER_P (TYPE_SIZE (operation_type))))
{
- right_operand = convert (operation_type, right_operand);
+ right_operand = gnat_convert_internal (operation_type, right_operand);
right_type = operation_type;
}
@@ -734,8 +734,8 @@
/* First convert the right operand to its base type. This will
prevent unneeded signedness conversions when sizetype is wider than
integer. */
- right_operand = convert (right_base_type, right_operand);
- right_operand = convert (TYPE_DOMAIN (left_type), right_operand);
+ right_operand = gnat_convert_internal (right_base_type, right_operand);
+ right_operand = gnat_convert_internal (TYPE_DOMAIN (left_type), right_operand);
if (!TREE_CONSTANT (right_operand)
|| !TREE_CONSTANT (TYPE_MIN_VALUE (right_type)))
@@ -772,7 +772,7 @@
if (TREE_CODE (left_type) == RECORD_TYPE
&& TYPE_JUSTIFIED_MODULAR_P (left_type))
{
- left_operand = convert (TREE_TYPE (TYPE_FIELDS (left_type)),
+ left_operand = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (left_type)),
left_operand);
left_type = TREE_TYPE (left_operand);
left_base_type = get_base_type (left_type);
@@ -781,7 +781,7 @@
if (TREE_CODE (right_type) == RECORD_TYPE
&& TYPE_JUSTIFIED_MODULAR_P (right_type))
{
- right_operand = convert (TREE_TYPE (TYPE_FIELDS (right_type)),
+ right_operand = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (right_type)),
right_operand);
right_type = TREE_TYPE (right_operand);
right_base_type = get_base_type (right_type);
@@ -834,8 +834,8 @@
else
gcc_unreachable ();
- left_operand = convert (best_type, left_operand);
- right_operand = convert (best_type, right_operand);
+ left_operand = gnat_convert_internal (best_type, left_operand);
+ right_operand = gnat_convert_internal (best_type, right_operand);
}
else
gcc_unreachable ();
@@ -853,13 +853,13 @@
right_operand = build_component_ref (left_operand, NULL_TREE,
TYPE_FIELDS (left_base_type),
false);
- left_operand = convert (TREE_TYPE (right_operand),
+ left_operand = gnat_convert_internal (TREE_TYPE (right_operand),
integer_zero_node);
}
else
{
- left_operand = convert (left_base_type, left_operand);
- right_operand = convert (right_base_type, right_operand);
+ left_operand = gnat_convert_internal (left_base_type, left_operand);
+ right_operand = gnat_convert_internal (right_base_type, right_operand);
}
modulus = NULL_TREE;
@@ -879,8 +879,8 @@
gcc_assert (left_type == result_type);
operation_type = get_base_type (result_type);
- left_operand = convert (operation_type, left_operand);
- right_operand = convert (operation_type, right_operand);
+ left_operand = gnat_convert_internal (operation_type, left_operand);
+ right_operand = gnat_convert_internal (operation_type, right_operand);
has_side_effects = true;
modulus = NULL_TREE;
break;
@@ -894,7 +894,7 @@
to modular types). Otherwise, processing is the same as normal. */
gcc_assert (operation_type == left_base_type);
modulus = NULL_TREE;
- left_operand = convert (operation_type, left_operand);
+ left_operand = gnat_convert_internal (operation_type, left_operand);
break;
case TRUTH_ANDIF_EXPR:
@@ -919,8 +919,8 @@
case COMPLEX_EXPR:
gcc_assert (TREE_TYPE (result_type) == left_base_type
&& TREE_TYPE (result_type) == right_base_type);
- left_operand = convert (left_base_type, left_operand);
- right_operand = convert (right_base_type, right_operand);
+ left_operand = gnat_convert_internal (left_base_type, left_operand);
+ right_operand = gnat_convert_internal (right_base_type, right_operand);
break;
case TRUNC_DIV_EXPR: case TRUNC_MOD_EXPR:
@@ -939,8 +939,8 @@
gcc_assert (operation_type == left_base_type
&& left_base_type == right_base_type);
- left_operand = convert (operation_type, left_operand);
- right_operand = convert (operation_type, right_operand);
+ left_operand = gnat_convert_internal (operation_type, left_operand);
+ right_operand = gnat_convert_internal (operation_type, right_operand);
}
if (modulus && !integer_pow2p (modulus))
@@ -974,10 +974,10 @@
if something above hasn't eliminated the need for it. */
if (modulus)
result = fold (build2 (FLOOR_MOD_EXPR, operation_type, result,
- convert (operation_type, modulus)));
+ gnat_convert_internal (operation_type, modulus)));
if (result_type && result_type != operation_type)
- result = convert (result_type, result);
+ result = gnat_convert_internal (result_type, result);
return result;
}
@@ -1066,7 +1066,7 @@
&& (CONTAINS_PLACEHOLDER_P
(TYPE_SIZE (TREE_TYPE (TYPE_FIELDS
(TREE_TYPE (inner)))))))
- inner = convert (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (inner))),
+ inner = gnat_convert_internal (TREE_TYPE (TYPE_FIELDS (TREE_TYPE (inner))),
inner);
/* Compute the offset as a byte offset from INNER. */
@@ -1085,11 +1085,11 @@
add then. It will later be converted to the desired result
type, if any. */
inner = build_unary_op (ADDR_EXPR, NULL_TREE, inner);
- inner = convert (ptr_void_type_node, inner);
- offset = convert (ptr_void_type_node, offset);
+ inner = gnat_convert_internal (ptr_void_type_node, inner);
+ offset = gnat_convert_internal (ptr_void_type_node, offset);
result = build_binary_op (PLUS_EXPR, ptr_void_type_node,
inner, offset);
- result = convert (build_pointer_type (TREE_TYPE (operand)),
+ result = gnat_convert_internal (build_pointer_type (TREE_TYPE (operand)),
result);
break;
}
@@ -1106,7 +1106,7 @@
0)
->value);
- result = convert (build_pointer_type (TREE_TYPE (operand)),
+ result = gnat_convert_internal (build_pointer_type (TREE_TYPE (operand)),
build_unary_op (ADDR_EXPR, NULL_TREE, result));
break;
}
@@ -1153,7 +1153,7 @@
&& TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (TYPE_FIELDS (type))))
{
type = TREE_TYPE (TYPE_FIELDS (type));
- operand = convert (type, operand);
+ operand = gnat_convert_internal (type, operand);
}
if (type != error_mark_node)
@@ -1175,7 +1175,7 @@
&& TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type)))
{
operand
- = convert (TREE_TYPE (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type))),
+ = gnat_convert_internal (TREE_TYPE (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type))),
operand);
type = TREE_TYPE (operand);
}
@@ -1216,7 +1216,7 @@
if (modulus)
{
gcc_assert (operation_type == base_type);
- operand = convert (operation_type, operand);
+ operand = gnat_convert_internal (operation_type, operand);
/* The fastest in the negate case for binary modulus is
the straightforward code; the TRUNC_MOD_EXPR below
@@ -1235,7 +1235,7 @@
{
if (integer_pow2p (fold (build2 (PLUS_EXPR, operation_type,
modulus,
- convert (operation_type,
+ gnat_convert_internal (operation_type,
integer_one_node)))))
result = fold (build2 (BIT_XOR_EXPR, operation_type,
operand, modulus));
@@ -1247,7 +1247,7 @@
fold (build2 (NE_EXPR,
integer_type_node,
operand,
- convert
+ gnat_convert_internal
(operation_type,
integer_zero_node))),
result, operand));
@@ -1260,7 +1260,7 @@
that constant for nonbinary modulus. */
tree cnst = fold (build2 (MINUS_EXPR, operation_type, modulus,
- convert (operation_type,
+ gnat_convert_internal (operation_type,
integer_one_node)));
if (mod_pow2)
@@ -1279,7 +1279,7 @@
default:
gcc_assert (operation_type == base_type);
- result = fold (build1 (op_code, operation_type, convert (operation_type,
+ result = fold (build1 (op_code, operation_type, gnat_convert_internal (operation_type,
operand)));
}
@@ -1291,7 +1291,7 @@
}
if (result_type && TREE_TYPE (result) != result_type)
- result = convert (result_type, result);
+ result = gnat_convert_internal (result_type, result);
return result;
}
@@ -1308,8 +1308,8 @@
/* The front-end verifies that result, true and false operands have same base
type. Convert everything to the result type. */
- true_operand = convert (result_type, true_operand);
- false_operand = convert (result_type, false_operand);
+ true_operand = gnat_convert_internal (result_type, true_operand);
+ false_operand = gnat_convert_internal (result_type, false_operand);
/* If the result type is unconstrained, take the address of
the operands and then dereference our result. */
@@ -1377,7 +1377,7 @@
would use the "target pointer" return mechanism. */
if (operation_type != TREE_TYPE (ret_val))
- ret_val = convert (operation_type, ret_val);
+ ret_val = gnat_convert_internal (operation_type, ret_val);
result_expr
= build2 (MODIFY_EXPR, operation_type, result_decl, ret_val);
@@ -1736,11 +1736,11 @@
gnu_args
= chainon (gnu_args,
build_tree_list (NULL_TREE,
- convert (gnu_size_type, gnu_size)));
+ gnat_convert_internal (gnu_size_type, gnu_size)));
gnu_args
= chainon (gnu_args,
build_tree_list (NULL_TREE,
- convert (gnu_size_type, gnu_align)));
+ gnat_convert_internal (gnu_size_type, gnu_align)));
gnu_call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
gnu_proc_addr, gnu_args, NULL_TREE);
@@ -1769,7 +1769,7 @@
gnu_args
= chainon (gnu_args,
build_tree_list (NULL_TREE,
- convert (gnu_size_type, gnu_size)));
+ gnat_convert_internal (gnu_size_type, gnu_size)));
gnu_call = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (gnu_proc)),
gnu_proc_addr, gnu_args, NULL_TREE);
@@ -1798,7 +1798,7 @@
gnu_array_type, NULL_TREE, false, false, false,
false, NULL, gnat_node);
- return convert (ptr_void_type_node,
+ return gnat_convert_internal (ptr_void_type_node,
build_unary_op (ADDR_EXPR, NULL_TREE, gnu_decl));
}
else
@@ -1860,14 +1860,14 @@
storage = build_call_alloc_dealloc (NULL_TREE, size,
TYPE_ALIGN (storage_type),
gnat_proc, gnat_pool, gnat_node);
- storage = convert (storage_ptr_type, protect_multiple_eval (storage));
+ storage = gnat_convert_internal (storage_ptr_type, protect_multiple_eval (storage));
if (TREE_CODE (type) == RECORD_TYPE && TYPE_IS_PADDING_P (type))
{
type = TREE_TYPE (TYPE_FIELDS (type));
if (init)
- init = convert (type, init);
+ init = gnat_convert_internal (type, init);
}
/* If there is an initializing expression, make a constructor for
@@ -1883,15 +1883,15 @@
init),
template_cons);
- return convert
+ return gnat_convert_internal
(result_type,
build2 (COMPOUND_EXPR, storage_ptr_type,
build_binary_op
(MODIFY_EXPR, storage_type,
build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (storage_ptr_type, storage)),
+ gnat_convert_internal (storage_ptr_type, storage)),
gnat_build_constructor (storage_type, template_cons)),
- convert (storage_ptr_type, storage)));
+ gnat_convert_internal (storage_ptr_type, storage)));
}
else
return build2
@@ -1900,10 +1900,10 @@
(MODIFY_EXPR, template_type,
build_component_ref
(build_unary_op (INDIRECT_REF, NULL_TREE,
- convert (storage_ptr_type, storage)),
+ gnat_convert_internal (storage_ptr_type, storage)),
NULL_TREE, TYPE_FIELDS (storage_type), 0),
build_template (template_type, type, NULL_TREE)),
- convert (result_type, convert (storage_ptr_type, storage)));
+ gnat_convert_internal (result_type, gnat_convert_internal (storage_ptr_type, storage)));
}
/* If we have an initializing expression, see if its size is simpler
@@ -1943,15 +1943,15 @@
BIGGEST_ALIGNMENT, Empty,
Empty, gnat_node);
result = save_expr (result);
- result = convert (build_pointer_type (new_type), result);
+ result = gnat_convert_internal (build_pointer_type (new_type), result);
result = build_unary_op (INDIRECT_REF, NULL_TREE, result);
result = build_component_ref (result, NULL_TREE,
TYPE_FIELDS (new_type), 0);
- result = convert (result_type,
+ result = gnat_convert_internal (result_type,
build_unary_op (ADDR_EXPR, NULL_TREE, result));
}
else
- result = convert (result_type,
+ result = gnat_convert_internal (result_type,
build_call_alloc_dealloc (NULL_TREE, size,
TYPE_ALIGN (type),
gnat_proc,
@@ -1974,7 +1974,7 @@
result);
}
- return convert (result_type, result);
+ return gnat_convert_internal (result_type, result);
}
/* Fill in a VMS descriptor for EXPR and return a constructor for it.
@@ -1993,7 +1993,7 @@
for (field = TYPE_FIELDS (record_type); field; field = TREE_CHAIN (field))
const_list
= tree_cons (field,
- convert (TREE_TYPE (field),
+ gnat_convert_internal (TREE_TYPE (field),
SUBSTITUTE_PLACEHOLDER_IN_EXPR
(DECL_INITIAL (field), expr)),
const_list);
Index: gcc/ada/gigi.h
===================================================================
--- gcc/ada/gigi.h (revision 112530)
+++ gcc/ada/gigi.h (working copy)
@@ -461,7 +461,8 @@
is always TYPE. This function implements all reasonable
conversions; callers should filter out those that are
not permitted by the language being compiled. */
-extern tree convert (tree type, tree expr);
+extern tree gnat_convert (tree type, tree expr);
+extern tree gnat_convert_internal (tree type, tree expr);
/* Routines created solely for the tree translator's sake. Their prototypes
can be changed as desired. */
Index: gcc/ada/cuintp.c
===================================================================
--- gcc/ada/cuintp.c (revision 112530)
+++ gcc/ada/cuintp.c (working copy)
@@ -60,7 +60,7 @@
build_cst_from_int (tree type, HOST_WIDE_INT low)
{
if (TREE_CODE (type) == REAL_TYPE)
- return convert (type, build_int_cst (NULL_TREE, low));
+ return gnat_convert_internal (type, build_int_cst (NULL_TREE, low));
else
return force_fit_type (build_int_cst (type, low), false, false, false);
}
@@ -127,7 +127,7 @@
Udigits_Ptr[Idx])));
}
- gnu_ret = convert (type, gnu_ret);
+ gnu_ret = gnat_convert_internal (type, gnu_ret);
/* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RET. */
while ((TREE_CODE (gnu_ret) == NOP_EXPR
Index: gcc/c-decl.c
===================================================================
--- gcc/c-decl.c (revision 112530)
+++ gcc/c-decl.c (working copy)
@@ -4254,8 +4254,8 @@
if it is a variable the computations will be
done in the proper mode. */
itype = fold_build2 (MINUS_EXPR, index_type,
- convert (index_type, size),
- convert (index_type,
+ c_convert_internal (index_type, size),
+ c_convert_internal (index_type,
size_one_node));
/* If that overflowed, the array is too big. ???
@@ -5726,7 +5726,7 @@
tem = integer_type_node;
else
tem = enumtype;
- ini = convert (tem, ini);
+ ini = c_convert_internal (tem, ini);
DECL_INITIAL (enu) = ini;
TREE_PURPOSE (pair) = DECL_NAME (enu);
@@ -5813,7 +5813,7 @@
pedwarn ("ISO C restricts enumerator values to range of %<int%>");
/* XXX This causes -pedantic to change the meaning of the program.
Remove? -zw 2004-03-15 */
- value = convert (integer_type_node, value);
+ value = c_convert_internal (integer_type_node, value);
}
/* Set basis for default for next value. */
@@ -5830,7 +5830,7 @@
&& TYPE_UNSIGNED (type)));
decl = build_decl (CONST_DECL, name, type);
- DECL_INITIAL (decl) = convert (type, value);
+ DECL_INITIAL (decl) = c_convert_internal (type, value);
pushdecl (decl);
return tree_cons (decl, value, NULL_TREE);
Index: gcc/fortran/trans-expr.c
===================================================================
--- gcc/fortran/trans-expr.c (revision 112530)
+++ gcc/fortran/trans-expr.c (working copy)
@@ -498,7 +498,7 @@
All other unary operators have an equivalent GIMPLE unary operator. */
if (code == TRUTH_NOT_EXPR)
se->expr = build2 (EQ_EXPR, type, operand.expr,
- convert (type, integer_zero_node));
+ convert2 (type, integer_zero_node));
else
se->expr = build1 (code, type, operand.expr);
@@ -630,7 +630,7 @@
tmp = build2 (EQ_EXPR, boolean_type_node, lhs,
fold_convert (TREE_TYPE (lhs), integer_minus_one_node));
cond = build2 (EQ_EXPR, boolean_type_node, lhs,
- convert (TREE_TYPE (lhs), integer_one_node));
+ convert2 (TREE_TYPE (lhs), integer_one_node));
/* If rhs is even,
result = (lhs == 1 || lhs == -1) ? 1 : 0. */
@@ -638,17 +638,17 @@
{
tmp = build2 (TRUTH_OR_EXPR, boolean_type_node, tmp, cond);
se->expr = build3 (COND_EXPR, type, tmp,
- convert (type, integer_one_node),
- convert (type, integer_zero_node));
+ convert2 (type, integer_one_node),
+ convert2 (type, integer_zero_node));
return 1;
}
/* If rhs is odd,
result = (lhs == 1) ? 1 : (lhs == -1) ? -1 : 0. */
tmp = build3 (COND_EXPR, type, tmp,
- convert (type, integer_minus_one_node),
- convert (type, integer_zero_node));
+ convert2 (type, integer_minus_one_node),
+ convert2 (type, integer_zero_node));
se->expr = build3 (COND_EXPR, type, cond,
- convert (type, integer_one_node),
+ convert2 (type, integer_one_node),
tmp);
return 1;
}
@@ -705,7 +705,7 @@
{
case 1:
case 2:
- rse.expr = convert (gfc_int4_type_node, rse.expr);
+ rse.expr = convert2 (gfc_int4_type_node, rse.expr);
/* Fall through. */
case 4:
@@ -728,7 +728,7 @@
case 1:
case 2:
if (expr->value.op.op1->ts.type == BT_INTEGER)
- lse.expr = convert (gfc_int4_type_node, lse.expr);
+ lse.expr = convert2 (gfc_int4_type_node, lse.expr);
else
gcc_unreachable ();
/* Fall through. */
@@ -838,7 +838,7 @@
{
/* Create a temporary variable to hold the result. */
tmp = fold_build2 (MINUS_EXPR, gfc_charlen_type_node, len,
- convert (gfc_charlen_type_node, integer_one_node));
+ convert2 (gfc_charlen_type_node, integer_one_node));
tmp = build_range_type (gfc_array_index_type, gfc_index_zero_node, tmp);
tmp = build_array_type (gfc_character1_type_node, tmp);
var = gfc_create_var (tmp, "str");
@@ -850,11 +850,11 @@
var = gfc_create_var (type, "pstr");
args = gfc_chainon_list (NULL_TREE, len);
tmp = build_function_call_expr (gfor_fndecl_internal_malloc, args);
- tmp = convert (type, tmp);
+ tmp = convert2 (type, tmp);
gfc_add_modify_expr (&se->pre, var, tmp);
/* Free the temporary afterwards. */
- tmp = convert (pvoid_type_node, var);
+ tmp = convert2 (pvoid_type_node, var);
args = gfc_chainon_list (NULL_TREE, tmp);
tmp = build_function_call_expr (gfor_fndecl_internal_free, args);
gfc_add_expr_to_block (&se->post, tmp);
@@ -1081,7 +1081,7 @@
{
/* The result of logical ops is always boolean_type_node. */
tmp = fold_build2 (code, type, lse.expr, rse.expr);
- se->expr = convert (type, tmp);
+ se->expr = convert2 (type, tmp);
}
else
se->expr = fold_build2 (code, type, lse.expr, rse.expr);
@@ -1864,7 +1864,7 @@
gfc_init_se (&parmse, NULL);
parmse.expr = null_pointer_node;
if (arg->missing_arg_type == BT_CHARACTER)
- parmse.string_length = convert (gfc_charlen_type_node,
+ parmse.string_length = convert2 (gfc_charlen_type_node,
integer_zero_node);
}
}
@@ -2000,7 +2000,7 @@
/* Zero the first stride to indicate a temporary. */
tmp = gfc_conv_descriptor_stride (info->descriptor, gfc_rank_cst[0]);
gfc_add_modify_expr (&se->pre, tmp,
- convert (TREE_TYPE (tmp), integer_zero_node));
+ convert2 (TREE_TYPE (tmp), integer_zero_node));
/* Pass the temporary as the first argument. */
tmp = info->descriptor;
@@ -2720,7 +2720,7 @@
gfc_conv_expr_type (gfc_se * se, gfc_expr * expr, tree type)
{
gfc_conv_expr_val (se, expr);
- se->expr = convert (type, se->expr);
+ se->expr = convert2 (type, se->expr);
}
Index: gcc/fortran/trans-array.c
===================================================================
--- gcc/fortran/trans-array.c (revision 112530)
+++ gcc/fortran/trans-array.c (working copy)
@@ -1525,7 +1525,7 @@
/* Move the evaluation of scalar expressions outside the
scalarization loop. */
if (subscript)
- se.expr = convert(gfc_array_index_type, se.expr);
+ se.expr = convert2 (gfc_array_index_type, se.expr);
se.expr = gfc_evaluate_now (se.expr, &loop->pre);
gfc_add_block_to_block (&loop->pre, &se.post);
}
@@ -3399,7 +3399,7 @@
else
gcc_unreachable ();
tmp = build_function_call_expr (fndecl, tmp);
- tmp = fold (convert (TREE_TYPE (decl), tmp));
+ tmp = fold (convert2 (TREE_TYPE (decl), tmp));
gfc_add_modify_expr (&block, decl, tmp);
/* Set offset of the array. */
@@ -3413,7 +3413,7 @@
gfc_add_expr_to_block (&block, fnbody);
/* Free the temporary. */
- tmp = convert (pvoid_type_node, decl);
+ tmp = convert2 (pvoid_type_node, decl);
tmp = gfc_chainon_list (NULL_TREE, tmp);
tmp = build_function_call_expr (gfor_fndecl_internal_free, tmp);
gfc_add_expr_to_block (&block, tmp);
@@ -3458,7 +3458,7 @@
/* Set the pointer itself if we aren't using the parameter directly. */
if (TREE_CODE (parm) != PARM_DECL)
{
- tmp = convert (TREE_TYPE (parm), GFC_DECL_SAVED_DESCRIPTOR (parm));
+ tmp = convert2 (TREE_TYPE (parm), GFC_DECL_SAVED_DESCRIPTOR (parm));
gfc_add_modify_expr (&block, parm, tmp);
}
tmp = gfc_finish_block (&block);
@@ -4284,7 +4284,7 @@
gfc_add_expr_to_block (&block, tmp);
/* Free the temporary. */
- tmp = convert (pvoid_type_node, ptr);
+ tmp = convert2 (pvoid_type_node, ptr);
tmp = gfc_chainon_list (NULL_TREE, tmp);
tmp = build_function_call_expr (gfor_fndecl_internal_free, tmp);
gfc_add_expr_to_block (&block, tmp);
Index: gcc/fortran/Make-lang.in
===================================================================
--- gcc/fortran/Make-lang.in (revision 112530)
+++ gcc/fortran/Make-lang.in (working copy)
@@ -70,7 +70,7 @@
fortran/symbol.o
F95_OBJS = $(F95_PARSER_OBJS) \
- fortran/convert.o fortran/dependency.o fortran/f95-lang.o \
+ fortran/dependency.o fortran/f95-lang.o \
fortran/trans.o fortran/trans-array.o fortran/trans-common.o \
fortran/trans-const.o fortran/trans-decl.o fortran/trans-expr.o \
fortran/trans-intrinsic.o fortran/trans-io.o fortran/trans-openmp.o \
@@ -278,7 +278,6 @@
gt-fortran-f95-lang.h gtype-fortran.h cgraph.h $(TARGET_H) \
$(BUILTINS_DEF) fortran/types.def
fortran/scanner.o: toplev.h
-fortran/convert.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans-decl.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-decl.h \
cgraph.h $(TARGET_H) function.h $(FLAGS_H) $(RTL_H) tree-gimple.h \
Index: gcc/fortran/trans-openmp.c
===================================================================
--- gcc/fortran/trans-openmp.c (revision 112530)
+++ gcc/fortran/trans-openmp.c (working copy)
@@ -814,7 +814,7 @@
lhsaddr = save_expr (lhsaddr);
rhs = gfc_evaluate_now (rse.expr, &block);
- x = convert (TREE_TYPE (rhs), build_fold_indirect_ref (lhsaddr));
+ x = convert2 (TREE_TYPE (rhs), build_fold_indirect_ref (lhsaddr));
if (var_on_left)
x = fold_build2 (op, TREE_TYPE (rhs), x, rhs);
@@ -825,7 +825,7 @@
&& TREE_CODE (type) != COMPLEX_TYPE)
x = build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (rhs)), x);
- x = build2_v (OMP_ATOMIC, lhsaddr, convert (type, x));
+ x = build2_v (OMP_ATOMIC, lhsaddr, convert2 (type, x));
gfc_add_expr_to_block (&block, x);
gfc_add_block_to_block (&block, &lse.pre);
Index: gcc/fortran/trans-const.c
===================================================================
--- gcc/fortran/trans-const.c (revision 112530)
+++ gcc/fortran/trans-const.c (working copy)
@@ -52,7 +52,7 @@
switch (TREE_CODE (type))
{
case INTEGER_TYPE:
- val = convert (type, intval);
+ val = convert2 (type, intval);
break;
case REAL_TYPE:
Index: gcc/fortran/trans-stmt.c
===================================================================
--- gcc/fortran/trans-stmt.c (revision 112530)
+++ gcc/fortran/trans-stmt.c (working copy)
@@ -238,7 +238,7 @@
select_code = code->next;
gcc_assert(select_code->op == EXEC_SELECT);
sym = select_code->expr->symtree->n.sym;
- se.expr = convert (gfc_typenode_for_spec (&sym->ts), se.expr);
+ se.expr = convert2 (gfc_typenode_for_spec (&sym->ts), se.expr);
gfc_add_modify_expr (&se.pre, sym->backend_decl, se.expr);
}
else
@@ -780,7 +780,7 @@
}
gfc_add_modify_expr (&block, count, tmp);
- count_one = convert (TREE_TYPE (count), integer_one_node);
+ count_one = convert2 (TREE_TYPE (count), integer_one_node);
/* Initialize the DO variable: dovar = from. */
gfc_add_modify_expr (&block, dovar, from);
@@ -1582,7 +1582,7 @@
else
{
tmpvar = gfc_create_var (build_pointer_type (type), "temp");
- *pdata = convert (pvoid_type_node, tmpvar);
+ *pdata = convert2 (pvoid_type_node, tmpvar);
args = gfc_chainon_list (NULL_TREE, bytesize);
if (gfc_index_integer_kind == 4)
@@ -1592,7 +1592,7 @@
else
gcc_unreachable ();
tmp = build_function_call_expr (tmp, args);
- tmp = convert (TREE_TYPE (tmpvar), tmp);
+ tmp = convert2 (TREE_TYPE (tmpvar), tmp);
gfc_add_modify_expr (pblock, tmpvar, tmp);
}
return tmpvar;
@@ -2401,7 +2401,7 @@
tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (end[n]), end[n], tmp);
tmp = fold_build2 (FLOOR_DIV_EXPR, TREE_TYPE (tmp), tmp, step[n]);
- tmp = convert (gfc_array_index_type, tmp);
+ tmp = convert2 (gfc_array_index_type, tmp);
size = fold_build2 (MULT_EXPR, gfc_array_index_type, size, tmp);
}
@@ -2455,7 +2455,7 @@
gfc_add_block_to_block (&body, &se.pre);
/* Store the mask. */
- se.expr = convert (smallest_boolean_type_node, se.expr);
+ se.expr = convert2 (smallest_boolean_type_node, se.expr);
if (pmask)
tmp = build_fold_indirect_ref (mask);
@@ -3470,7 +3470,7 @@
gfc_init_se (&se, NULL);
gfc_conv_expr_lhs (&se, code->expr);
- tmp = convert (TREE_TYPE (se.expr), stat);
+ tmp = convert2 (TREE_TYPE (se.expr), stat);
gfc_add_modify_expr (&block, se.expr, tmp);
}
@@ -3574,7 +3574,7 @@
{
gfc_init_se (&se, NULL);
gfc_conv_expr_lhs (&se, code->expr);
- tmp = convert (TREE_TYPE (se.expr), astat);
+ tmp = convert2 (TREE_TYPE (se.expr), astat);
gfc_add_modify_expr (&block, se.expr, tmp);
}
Index: gcc/fortran/trans.c
===================================================================
--- gcc/fortran/trans.c (revision 112530)
+++ gcc/fortran/trans.c (working copy)
@@ -277,7 +277,7 @@
}
if (type && natural_type != type)
- t = convert (type, t);
+ t = convert2 (type, t);
return t;
}
Index: gcc/fortran/trans-io.c
===================================================================
--- gcc/fortran/trans-io.c (revision 112530)
+++ gcc/fortran/trans-io.c (working copy)
@@ -413,7 +413,7 @@
if (TYPE_MODE (TREE_TYPE (se.expr))
== TYPE_MODE (TREE_TYPE (TREE_TYPE (p->field))))
- addr = convert (TREE_TYPE (p->field),
+ addr = convert2 (TREE_TYPE (p->field),
build_fold_addr_expr (se.expr));
else
{
@@ -424,7 +424,7 @@
= gfc_create_var (TREE_TYPE (TREE_TYPE (p->field)),
st_parameter_field[type].name);
addr = build_fold_addr_expr (tmpvar);
- tmp = convert (TREE_TYPE (se.expr), tmpvar);
+ tmp = convert2 (TREE_TYPE (se.expr), tmpvar);
gfc_add_modify_expr (postblock, se.expr, tmp);
}
@@ -533,7 +533,7 @@
gfc_build_cstring_const ("Assigned label is not a format label");
tmp = GFC_DECL_STRING_LEN (se.expr);
tmp = build2 (LE_EXPR, boolean_type_node,
- tmp, convert (TREE_TYPE (tmp), integer_minus_one_node));
+ tmp, convert2 (TREE_TYPE (tmp), integer_minus_one_node));
gfc_trans_runtime_check (tmp, msg, &se.pre);
gfc_add_modify_expr (&se.pre, io,
fold_convert (TREE_TYPE (io), GFC_DECL_ASSIGN_ADDR (se.expr)));
@@ -1296,7 +1296,7 @@
if (ts->type == BT_CHARACTER)
NML_ADD_ARG (ts->cl->backend_decl);
else
- NML_ADD_ARG (convert (gfc_charlen_type_node, integer_zero_node));
+ NML_ADD_ARG (convert2 (gfc_charlen_type_node, integer_zero_node));
NML_ADD_ARG (dtype);
tmp = build_function_call_expr (iocall[IOCALL_SET_NML_VAL], args);
Index: gcc/fortran/trans-decl.c
===================================================================
--- gcc/fortran/trans-decl.c (revision 112530)
+++ gcc/fortran/trans-decl.c (working copy)
@@ -383,11 +383,11 @@
{
/* These decls will be dereferenced later, so we don't dereference
them here. */
- value = convert (TREE_TYPE (decl), ptr_decl);
+ value = convert2 (TREE_TYPE (decl), ptr_decl);
}
else
{
- ptr_decl = convert (build_pointer_type (TREE_TYPE (decl)),
+ ptr_decl = convert2 (build_pointer_type (TREE_TYPE (decl)),
ptr_decl);
value = build_fold_indirect_ref (ptr_decl);
}
@@ -1618,7 +1618,7 @@
args = tree_cons (NULL_TREE, null_pointer_node, args);
if (formal->sym->ts.type == BT_CHARACTER)
{
- tmp = convert (gfc_charlen_type_node, integer_zero_node);
+ tmp = convert2 (gfc_charlen_type_node, integer_zero_node);
string_args = tree_cons (NULL_TREE, tmp, string_args);
}
}
Index: gcc/fortran/convert.c
===================================================================
--- gcc/fortran/convert.c (revision 112530)
+++ gcc/fortran/convert.c (working copy)
@@ -1,124 +0,0 @@
-/* Language-level data type conversion for GNU C.
- Copyright (C) 1987, 1988, 1991, 1998, 2002 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
-
-
-/* This file contains the functions for converting C expressions
- to different data types. The only entry point is `convert'.
- Every language front end must have a `convert' function
- but what kind of conversions it does will depend on the language. */
-
-/* copied from the f77 frontend I think */
-
-/* copied from c-convert.c without significant modification*/
-/* Change of width--truncation and extension of integers or reals--
- is represented with NOP_EXPR. Proper functioning of many things
- assumes that no other conversions can be NOP_EXPRs.
-*/
-
-/* I've added support for WITH_RECORD_EXPR. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tree.h"
-#include "flags.h"
-#include "convert.h"
-#include "toplev.h"
-#include "gfortran.h"
-#include "trans.h"
-
-/*
- Conversion between integer and pointer is represented with CONVERT_EXPR.
- Converting integer to real uses FLOAT_EXPR
- and real to integer uses FIX_TRUNC_EXPR.
-
- Here is a list of all the functions that assume that widening and
- narrowing is always done with a NOP_EXPR:
- In convert.c, convert_to_integer.
- In c-typeck.c, build_binary_op (boolean ops), and
- c_common_truthvalue_conversion.
- In expr.c: expand_expr, for operands of a MULT_EXPR.
- In fold-const.c: fold.
- In tree.c: get_narrower and get_unwidened. */
-
-/* Subroutines of `convert'. */
-
-
-
-/* Create an expression whose value is that of EXPR,
- converted to type TYPE. The TREE_TYPE of the value
- is always TYPE. This function implements all reasonable
- conversions; callers should filter out those that are
- not permitted by the language being compiled. */
-/* We are assuming that given a SIMPLE val, the result will be a SIMPLE rhs.
- If this is not the case, we will abort with an internal error. */
-tree
-convert (tree type, tree expr)
-{
- tree e = expr;
- enum tree_code code = TREE_CODE (type);
-
- if (type == TREE_TYPE (expr)
- || TREE_CODE (expr) == ERROR_MARK
- || code == ERROR_MARK || TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
- return expr;
-
- if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
- return fold_build1 (NOP_EXPR, type, expr);
- if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
- return error_mark_node;
- if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
- {
- error ("void value not ignored as it ought to be");
- return error_mark_node;
- }
- if (code == VOID_TYPE)
- return build1 (CONVERT_EXPR, type, e);
-#if 0
- /* This is incorrect. A truncation can't be stripped this way.
- Extensions will be stripped by the use of get_unwidened. */
- if (TREE_CODE (expr) == NOP_EXPR)
- return convert (type, TREE_OPERAND (expr, 0));
-#endif
- if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
- return fold (convert_to_integer (type, e));
- if (code == BOOLEAN_TYPE)
- {
- e = gfc_truthvalue_conversion (e);
-
- /* If we have a NOP_EXPR, we must fold it here to avoid
- infinite recursion between fold () and convert (). */
- if (TREE_CODE (e) == NOP_EXPR)
- return fold_build1 (NOP_EXPR, type, TREE_OPERAND (e, 0));
- else
- return fold_build1 (NOP_EXPR, type, e);
- }
- if (code == POINTER_TYPE || code == REFERENCE_TYPE)
- return fold (convert_to_pointer (type, e));
- if (code == REAL_TYPE)
- return fold (convert_to_real (type, e));
- if (code == COMPLEX_TYPE)
- return fold (convert_to_complex (type, e));
- if (code == VECTOR_TYPE)
- return fold (convert_to_vector (type, e));
-
- error ("conversion to non-scalar type requested");
- return error_mark_node;
-}
Index: gcc/fortran/trans-intrinsic.c
===================================================================
--- gcc/fortran/trans-intrinsic.c (revision 112530)
+++ gcc/fortran/trans-intrinsic.c (working copy)
@@ -222,7 +222,7 @@
arg = build1 (REALPART_EXPR, artype, arg);
}
- se->expr = convert (type, arg);
+ se->expr = convert2 (type, arg);
}
/* This is needed because the gcc backend only implements
@@ -241,10 +241,10 @@
argtype = TREE_TYPE (arg);
arg = gfc_evaluate_now (arg, pblock);
- intval = convert (type, arg);
+ intval = convert2 (type, arg);
intval = gfc_evaluate_now (intval, pblock);
- tmp = convert (argtype, intval);
+ tmp = convert2 (argtype, intval);
cond = build2 (up ? GE_EXPR : LE_EXPR, boolean_type_node, tmp, arg);
tmp = build2 (up ? PLUS_EXPR : MINUS_EXPR, type, intval,
@@ -412,7 +412,7 @@
itype = gfc_get_int_type (kind);
tmp = build_fix_expr (&se->pre, arg, itype, op);
- tmp = convert (type, tmp);
+ tmp = convert2 (type, tmp);
se->expr = build3 (COND_EXPR, type, cond, tmp, arg);
mpfr_clear (huge);
}
@@ -435,7 +435,7 @@
if (TREE_CODE (TREE_TYPE (arg)) == INTEGER_TYPE)
{
/* Conversion to a different integer kind. */
- se->expr = convert (type, arg);
+ se->expr = convert2 (type, arg);
}
else
{
@@ -757,7 +757,7 @@
se->expr = gfc_conv_descriptor_lbound(desc, bound);
type = gfc_typenode_for_spec (&expr->ts);
- se->expr = convert (type, se->expr);
+ se->expr = convert2 (type, se->expr);
}
@@ -816,14 +816,14 @@
type = gfc_typenode_for_spec (&expr->ts);
arg = gfc_conv_intrinsic_function_args (se, expr);
- real = convert (TREE_TYPE (type), TREE_VALUE (arg));
+ real = convert2 (TREE_TYPE (type), TREE_VALUE (arg));
if (both)
- imag = convert (TREE_TYPE (type), TREE_VALUE (TREE_CHAIN (arg)));
+ imag = convert2 (TREE_TYPE (type), TREE_VALUE (TREE_CHAIN (arg)));
else if (TREE_CODE (TREE_TYPE (TREE_VALUE (arg))) == COMPLEX_TYPE)
{
arg = TREE_VALUE (arg);
imag = build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
- imag = convert (TREE_TYPE (type), imag);
+ imag = convert2 (TREE_TYPE (type), imag);
}
else
imag = build_real_from_int_cst (TREE_TYPE (type), integer_zero_node);
@@ -887,7 +887,7 @@
tmp = build_fix_expr (&se->pre, tmp, itype, FIX_FLOOR_EXPR);
else
tmp = build_fix_expr (&se->pre, tmp, itype, FIX_TRUNC_EXPR);
- tmp = convert (type, tmp);
+ tmp = convert2 (type, tmp);
tmp = build3 (COND_EXPR, type, test2, tmp, arg);
tmp = build2 (MULT_EXPR, type, tmp, arg2);
se->expr = build2 (MINUS_EXPR, type, arg, tmp);
@@ -988,7 +988,7 @@
arg = expr->value.function.actual->expr;
gcc_assert (arg->expr_type == EXPR_VARIABLE);
se->expr = gfc_conv_expr_present (arg->symtree->n.sym);
- se->expr = convert (gfc_typenode_for_spec (&expr->ts), se->expr);
+ se->expr = convert2 (gfc_typenode_for_spec (&expr->ts), se->expr);
}
@@ -1007,8 +1007,8 @@
/* Convert the args to double precision before multiplying. */
type = gfc_typenode_for_spec (&expr->ts);
- arg = convert (type, arg);
- arg2 = convert (type, arg2);
+ arg = convert2 (type, arg);
+ arg2 = convert2 (type, arg2);
se->expr = build2 (MULT_EXPR, type, arg, arg2);
}
@@ -1030,7 +1030,7 @@
type = gfc_character1_type_node;
var = gfc_create_var (type, "char");
- arg = convert (type, arg);
+ arg = convert2 (type, arg);
gfc_add_modify_expr (&se->pre, var, arg);
se->expr = gfc_build_addr_expr (build_pointer_type (type), var);
se->string_length = integer_one_node;
@@ -1180,7 +1180,7 @@
limit = TREE_VALUE (arg);
if (TREE_TYPE (limit) != type)
- limit = convert (type, limit);
+ limit = convert2 (type, limit);
/* Only evaluate the argument once. */
if (TREE_CODE (limit) != VAR_DECL && !TREE_CONSTANT (limit))
limit = gfc_evaluate_now(limit, &se->pre);
@@ -1191,13 +1191,13 @@
{
val = TREE_VALUE (arg);
if (TREE_TYPE (val) != type)
- val = convert (type, val);
+ val = convert2 (type, val);
/* Only evaluate the argument once. */
if (TREE_CODE (val) != VAR_DECL && !TREE_CONSTANT (val))
val = gfc_evaluate_now(val, &se->pre);
- thencase = build2_v (MODIFY_EXPR, mvar, convert (type, val));
+ thencase = build2_v (MODIFY_EXPR, mvar, convert2 (type, val));
tmp = build2 (op, boolean_type_node, val, limit);
tmp = build3_v (COND_EXPR, tmp, thencase, elsecase);
@@ -1303,9 +1303,9 @@
/* Initialize the result. */
resvar = gfc_create_var (type, "test");
if (op == EQ_EXPR)
- tmp = convert (type, boolean_true_node);
+ tmp = convert2 (type, boolean_true_node);
else
- tmp = convert (type, boolean_false_node);
+ tmp = convert2 (type, boolean_false_node);
gfc_add_modify_expr (&se->pre, resvar, tmp);
/* Walk the arguments. */
@@ -1329,9 +1329,9 @@
/* If the condition matches then set the return value. */
gfc_start_block (&block);
if (op == EQ_EXPR)
- tmp = convert (type, boolean_false_node);
+ tmp = convert2 (type, boolean_false_node);
else
- tmp = convert (type, boolean_true_node);
+ tmp = convert2 (type, boolean_true_node);
gfc_add_modify_expr (&block, resvar, tmp);
/* And break out of the loop. */
@@ -1583,7 +1583,7 @@
/* Initialize the result. */
resvar = gfc_create_var (type, "val");
if (expr->ts.type == BT_LOGICAL)
- tmp = convert (type, integer_zero_node);
+ tmp = convert2 (type, integer_zero_node);
else
tmp = gfc_build_const (type, integer_zero_node);
@@ -1839,7 +1839,7 @@
gfc_index_one_node);
tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, pos, tmp);
/* And convert to the required type. */
- se->expr = convert (type, tmp);
+ se->expr = convert2 (type, tmp);
}
static void
@@ -2005,7 +2005,7 @@
tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp,
build_int_cst (type, 0));
type = gfc_typenode_for_spec (&expr->ts);
- se->expr = convert (type, tmp);
+ se->expr = convert2 (type, tmp);
}
/* Generate code to perform the specified operation. */
@@ -2125,7 +2125,7 @@
numbers, and we try to be compatible with other compilers, most
notably g77, here. */
rshift = fold_convert (type, build2 (RSHIFT_EXPR, utype,
- convert (utype, arg), width));
+ convert2 (utype, arg), width));
tmp = fold_build2 (GE_EXPR, boolean_type_node, arg2,
build_int_cst (TREE_TYPE (arg2), 0));
@@ -2169,14 +2169,14 @@
aligned to at least 32 bits, so there's no loss. */
if (expr->ts.kind < 4)
{
- tmp = convert (int4type, TREE_VALUE (arg));
+ tmp =convert2 (int4type, TREE_VALUE (arg));
TREE_VALUE (arg) = tmp;
}
/* Convert the SHIFT and SIZE args to INTEGER*4 otherwise we would
need loads of library functions. They cannot have values >
BIT_SIZE (I) so the conversion is safe. */
- TREE_VALUE (arg2) = convert (int4type, TREE_VALUE (arg2));
- TREE_VALUE (arg3) = convert (int4type, TREE_VALUE (arg3));
+ TREE_VALUE (arg2) =convert2 (int4type, TREE_VALUE (arg2));
+ TREE_VALUE (arg3) =convert2 (int4type, TREE_VALUE (arg3));
switch (expr->ts.kind)
{
@@ -2198,7 +2198,7 @@
/* Convert the result back to the original type, if we extended
the first argument's width above. */
if (expr->ts.kind < 4)
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
return;
}
@@ -2272,7 +2272,7 @@
}
break;
}
- se->expr = convert (type, len);
+ se->expr =convert2 (type, len);
}
/* The length of a character string not including trailing blanks. */
@@ -2285,7 +2285,7 @@
args = gfc_conv_intrinsic_function_args (se, expr);
type = gfc_typenode_for_spec (&expr->ts);
se->expr = build_function_call_expr (gfor_fndecl_string_len_trim, args);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
@@ -2312,11 +2312,11 @@
else
{
back = TREE_CHAIN (tmp);
- TREE_VALUE (back) = convert (logical4_type_node, TREE_VALUE (back));
+ TREE_VALUE (back) =convert2 (logical4_type_node, TREE_VALUE (back));
}
se->expr = build_function_call_expr (gfor_fndecl_string_index, args);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
/* The ascii value for a single character. */
@@ -2333,7 +2333,7 @@
type = gfc_typenode_for_spec (&expr->ts);
se->expr = build_fold_indirect_ref (arg);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
@@ -2412,7 +2412,7 @@
se->expr = build_function_call_expr (fndecl, args);
type = gfc_typenode_for_spec (&expr->ts);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
@@ -2530,7 +2530,7 @@
/* Free the temporary. */
gfc_start_block (&block);
- tmp = convert (pvoid_type_node, source);
+ tmp = convert2 (pvoid_type_node, source);
tmp = gfc_chainon_list (NULL_TREE, tmp);
tmp = build_function_call_expr (gfor_fndecl_internal_free, tmp);
gfc_add_expr_to_block (&block, tmp);
@@ -2608,7 +2608,7 @@
{
gfc_init_se (&argse, NULL);
gfc_conv_expr_reference (&argse, arg->expr);
- tmp = convert (gfc_array_index_type,
+ tmp = convert2 (gfc_array_index_type,
build_fold_indirect_ref (argse.expr));
gfc_add_block_to_block (&se->pre, &argse.pre);
gfc_add_block_to_block (&se->post, &argse.post);
@@ -2702,7 +2702,7 @@
arg = arg->next;
type = gfc_typenode_for_spec (&expr->ts);
- ptr = convert (build_pointer_type (type), ptr);
+ ptr =convert2 (build_pointer_type (type), ptr);
if (expr->ts.type == BT_CHARACTER)
{
gfc_init_se (&argse, NULL);
@@ -2739,7 +2739,7 @@
tmp = gfc_conv_descriptor_data_get (arg1se.expr);
tmp = build2 (NE_EXPR, boolean_type_node, tmp,
fold_convert (TREE_TYPE (tmp), null_pointer_node));
- se->expr = convert (gfc_typenode_for_spec (&expr->ts), tmp);
+ se->expr =convert2 (gfc_typenode_for_spec (&expr->ts), tmp);
}
@@ -2820,7 +2820,7 @@
se->expr = build_function_call_expr (fndecl, args);
}
}
- se->expr = convert (gfc_typenode_for_spec (&expr->ts), se->expr);
+ se->expr =convert2 (gfc_typenode_for_spec (&expr->ts), se->expr);
}
@@ -2847,11 +2847,11 @@
else
{
back = TREE_CHAIN (tmp);
- TREE_VALUE (back) = convert (logical4_type_node, TREE_VALUE (back));
+ TREE_VALUE (back) =convert2 (logical4_type_node, TREE_VALUE (back));
}
se->expr = build_function_call_expr (gfor_fndecl_string_scan, args);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
@@ -2880,11 +2880,11 @@
else
{
back = TREE_CHAIN (tmp);
- TREE_VALUE (back) = convert (logical4_type_node, TREE_VALUE (back));
+ TREE_VALUE (back) =convert2 (logical4_type_node, TREE_VALUE (back));
}
se->expr = build_function_call_expr (gfor_fndecl_string_verify, args);
- se->expr = convert (type, se->expr);
+ se->expr =convert2 (type, se->expr);
}
/* Prepare components and related information of a real number which is
@@ -2924,9 +2924,9 @@
/* Calculate the numbers of bits of exponent, fraction and word */
n = gfc_validate_kind (a1->ts.type, a1->ts.kind, false);
tmp = build_int_cst (NULL_TREE, gfc_real_kinds[n].digits - 1);
- rcs->fdigits = convert (masktype, tmp);
+ rcs->fdigits =convert2 (masktype, tmp);
wbits = build_int_cst (NULL_TREE, TYPE_PRECISION (rcs->type) - 1);
- wbits = convert (masktype, wbits);
+ wbits =convert2 (masktype, wbits);
rcs->edigits = fold_build2 (MINUS_EXPR, masktype, wbits, tmp);
/* Form masks for exponent/fraction/sign */
@@ -2976,7 +2976,7 @@
parms = tree_cons (NULL, op0, NULL);
call = build_function_call_expr (fn, parms);
- return convert (result_type, call);
+ return convert2 (result_type, call);
}
@@ -3241,7 +3241,7 @@
gfc_conv_expr_reference (se, arg_expr);
else
gfc_conv_array_parameter (se, arg_expr, ss, 1);
- se->expr= convert (gfc_unsigned_type (long_integer_type_node),
+ se->expr=convert2 (gfc_unsigned_type (long_integer_type_node),
se->expr);
/* Create a temporary variable for loc return value. Without this,
Index: gcc/langhooks.c
===================================================================
--- gcc/langhooks.c (revision 112530)
+++ gcc/langhooks.c (working copy)
@@ -36,6 +36,8 @@
#include "langhooks-def.h"
#include "ggc.h"
#include "diagnostic.h"
+#include "convert.h"
+#include "c-common.h"
/* Do nothing; in many cases the default hook. */
@@ -578,3 +580,1750 @@
tree t ATTRIBUTE_UNUSED)
{
}
+
+static bool
+c_promoting_integer_type_p2 (tree t)
+{
+ switch (TREE_CODE (t))
+ {
+ case INTEGER_TYPE:
+ return (TYPE_MAIN_VARIANT (t) == char_type_node
+ || TYPE_MAIN_VARIANT (t) == signed_char_type_node
+ || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
+ || TYPE_MAIN_VARIANT (t) == short_integer_type_node
+ || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
+ || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
+
+ case ENUMERAL_TYPE:
+ /* ??? Technically all enumerations not larger than an int
+ promote to an int. But this is used along code paths
+ that only want to notice a size change. */
+ return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
+
+ case BOOLEAN_TYPE:
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
+static tree
+c_common_type_for_size2 (unsigned int bits, int unsignedp)
+{
+ if (bits == TYPE_PRECISION (integer_type_node))
+ return unsignedp ? unsigned_type_node : integer_type_node;
+
+ if (bits == TYPE_PRECISION (signed_char_type_node))
+ return unsignedp ? unsigned_char_type_node : signed_char_type_node;
+
+ if (bits == TYPE_PRECISION (short_integer_type_node))
+ return unsignedp ? short_unsigned_type_node : short_integer_type_node;
+
+ if (bits == TYPE_PRECISION (long_integer_type_node))
+ return unsignedp ? long_unsigned_type_node : long_integer_type_node;
+
+ if (bits == TYPE_PRECISION (long_long_integer_type_node))
+ return (unsignedp ? long_long_unsigned_type_node
+ : long_long_integer_type_node);
+
+/* if (bits == TYPE_PRECISION (widest_integer_literal_type_node)) */
+/* return (unsignedp ? widest_unsigned_literal_type_node */
+/* : widest_integer_literal_type_node); */
+
+ if (bits <= TYPE_PRECISION (intQI_type_node))
+ return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
+
+ if (bits <= TYPE_PRECISION (intHI_type_node))
+ return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
+
+ if (bits <= TYPE_PRECISION (intSI_type_node))
+ return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
+
+ if (bits <= TYPE_PRECISION (intDI_type_node))
+ return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
+
+ return 0;
+}
+
+static tree
+perform_integral_promotions2 (tree exp)
+{
+ tree type = TREE_TYPE (exp);
+ enum tree_code code = TREE_CODE (type);
+
+ gcc_assert (INTEGRAL_TYPE_P (type));
+
+ /* Normally convert enums to int,
+ but convert wide enums to something wider. */
+ if (code == ENUMERAL_TYPE)
+ {
+ type = c_common_type_for_size2 (MAX (TYPE_PRECISION (type),
+ TYPE_PRECISION (integer_type_node)),
+ ((TYPE_PRECISION (type)
+ >= TYPE_PRECISION (integer_type_node))
+ && TYPE_UNSIGNED (type)));
+
+ return convert2 (type, exp);
+ }
+
+ /* ??? This should no longer be needed now bit-fields have their
+ proper types. */
+ if (TREE_CODE (exp) == COMPONENT_REF
+ && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
+ /* If it's thinner than an int, promote it like a
+ c_promoting_integer_type_p, otherwise leave it alone. */
+ && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
+ TYPE_PRECISION (integer_type_node)))
+ return convert2 (integer_type_node, exp);
+
+ if (c_promoting_integer_type_p2 (type))
+ {
+ /* Preserve unsignedness if not really getting any wider. */
+ if (TYPE_UNSIGNED (type)
+ && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
+ return convert2 (unsigned_type_node, exp);
+
+ return convert2 (integer_type_node, exp);
+ }
+
+ return exp;
+}
+
+static tree
+default_conversion2 (tree exp)
+{
+ tree orig_exp;
+ tree type = TREE_TYPE (exp);
+ enum tree_code code = TREE_CODE (type);
+
+ /* Functions and arrays have been converted during parsing. */
+ gcc_assert (code != FUNCTION_TYPE);
+ if (code == ARRAY_TYPE)
+ return exp;
+
+ /* Constants can be used directly unless they're not loadable. */
+ if (TREE_CODE (exp) == CONST_DECL)
+ exp = DECL_INITIAL (exp);
+
+ /* Replace a nonvolatile const static variable with its value unless
+ it is an array, in which case we must be sure that taking the
+ address of the array produces consistent results. */
+ else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
+ {
+/* exp = decl_constant_value_for_broken_optimization (exp); */
+/* type = TREE_TYPE (exp); */
+ }
+
+ /* Strip no-op conversions. */
+ orig_exp = exp;
+ STRIP_TYPE_NOPS (exp);
+
+ if (TREE_NO_WARNING (orig_exp))
+ TREE_NO_WARNING (exp) = 1;
+
+ if (INTEGRAL_TYPE_P (type))
+ return perform_integral_promotions2 (exp);
+
+ if (code == VOID_TYPE)
+ {
+ error ("void value not ignored as it ought to be");
+ return error_mark_node;
+ }
+ return exp;
+}
+
+static tree
+c_common_type (tree t1, tree t2)
+{
+ enum tree_code code1;
+ enum tree_code code2;
+
+ /* If one type is nonsense, use the other. */
+ if (t1 == error_mark_node)
+ return t2;
+ if (t2 == error_mark_node)
+ return t1;
+
+ if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
+ t1 = TYPE_MAIN_VARIANT (t1);
+
+ if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
+ t2 = TYPE_MAIN_VARIANT (t2);
+
+ if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
+ t1 = build_type_attribute_variant (t1, NULL_TREE);
+
+ if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
+ t2 = build_type_attribute_variant (t2, NULL_TREE);
+
+ /* Save time if the two types are the same. */
+
+ if (t1 == t2) return t1;
+
+ code1 = TREE_CODE (t1);
+ code2 = TREE_CODE (t2);
+
+ gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
+ || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
+ gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
+ || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
+
+ /* If one type is a vector type, return that type. (How the usual
+ arithmetic conversions apply to the vector types extension is not
+ precisely specified.) */
+ if (code1 == VECTOR_TYPE)
+ return t1;
+
+ if (code2 == VECTOR_TYPE)
+ return t2;
+
+ /* If one type is complex, form the common type of the non-complex
+ components, then make that complex. Use T1 or T2 if it is the
+ required type. */
+ if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
+ {
+ tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
+ tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
+ tree subtype = c_common_type (subtype1, subtype2);
+
+ if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
+ return t1;
+ else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
+ return t2;
+ else
+ return build_complex_type (subtype);
+ }
+
+ /* If only one is real, use it as the result. */
+
+ if (code1 == REAL_TYPE && code2 != REAL_TYPE)
+ return t1;
+
+ if (code2 == REAL_TYPE && code1 != REAL_TYPE)
+ return t2;
+
+ /* If both are real and either are decimal floating point types, use
+ the decimal floating point type with the greater precision. */
+
+ if (code1 == REAL_TYPE && code2 == REAL_TYPE)
+ {
+ if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
+ || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
+ return dfloat128_type_node;
+ else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
+ || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
+ return dfloat64_type_node;
+ else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
+ || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
+ return dfloat32_type_node;
+ }
+
+ /* Both real or both integers; use the one with greater precision. */
+
+ if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
+ return t1;
+ else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
+ return t2;
+
+ /* Same precision. Prefer long longs to longs to ints when the
+ same precision, following the C99 rules on integer type rank
+ (which are equivalent to the C90 rules for C90 types). */
+
+ if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
+ return long_long_unsigned_type_node;
+
+ if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
+ {
+ if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
+ return long_long_unsigned_type_node;
+ else
+ return long_long_integer_type_node;
+ }
+
+ if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
+ return long_unsigned_type_node;
+
+ if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
+ {
+ /* But preserve unsignedness from the other type,
+ since long cannot hold all the values of an unsigned int. */
+ if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
+ return long_unsigned_type_node;
+ else
+ return long_integer_type_node;
+ }
+
+ /* Likewise, prefer long double to double even if same size. */
+ if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
+ || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
+ return long_double_type_node;
+
+ /* Otherwise prefer the unsigned one. */
+
+ if (TYPE_UNSIGNED (t1))
+ return t1;
+ else
+ return t2;
+}
+
+static tree
+c_common_signed_or_unsigned_type2 (int unsignedp, tree type)
+{
+ if (!INTEGRAL_TYPE_P (type)
+ || TYPE_UNSIGNED (type) == unsignedp)
+ return type;
+
+ /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
+ the precision; they have precision set to match their range, but
+ may use a wider mode to match an ABI. If we change modes, we may
+ wind up with bad conversions. For INTEGER_TYPEs in C, must check
+ the precision as well, so as to yield correct results for
+ bit-field types. C++ does not have these separate bit-field
+ types, and producing a signed or unsigned variant of an
+ ENUMERAL_TYPE may cause other problems as well. */
+
+#define TYPE_OK(node) \
+ (TYPE_MODE (type) == TYPE_MODE (node) \
+ && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
+/* if (TYPE_OK (signed_char_type_node)) */
+/* return unsignedp ? unsigned_char_type_node : signed_char_type_node; */
+/* if (TYPE_OK (integer_type_node)) */
+/* return unsignedp ? unsigned_type_node : integer_type_node; */
+/* if (TYPE_OK (short_integer_type_node)) */
+/* return unsignedp ? short_unsigned_type_node : short_integer_type_node; */
+/* if (TYPE_OK (long_integer_type_node)) */
+/* return unsignedp ? long_unsigned_type_node : long_integer_type_node; */
+/* if (TYPE_OK (long_long_integer_type_node)) */
+/* return (unsignedp ? long_long_unsigned_type_node */
+/* : long_long_integer_type_node); */
+/* if (TYPE_OK (widest_integer_literal_type_node)) */
+/* return (unsignedp ? widest_unsigned_literal_type_node */
+/* : widest_integer_literal_type_node); */
+
+#if HOST_BITS_PER_WIDE_INT >= 64
+ if (TYPE_OK (intTI_type_node))
+ return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
+#endif
+/* if (TYPE_OK (intDI_type_node)) */
+/* return unsignedp ? unsigned_intDI_type_node : intDI_type_node; */
+/* if (TYPE_OK (intSI_type_node)) */
+/* return unsignedp ? unsigned_intSI_type_node : intSI_type_node; */
+/* if (TYPE_OK (intHI_type_node)) */
+/* return unsignedp ? unsigned_intHI_type_node : intHI_type_node; */
+/* if (TYPE_OK (intQI_type_node)) */
+/* return unsignedp ? unsigned_intQI_type_node : intQI_type_node; */
+#undef TYPE_OK
+
+/* if (c_dialect_cxx ()) */
+ return type;
+/* else */
+/* return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp); */
+}
+
+static tree
+shorten_compare2 (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
+ enum tree_code *rescode_ptr)
+{
+ tree type;
+ tree op0 = *op0_ptr;
+ tree op1 = *op1_ptr;
+ int unsignedp0, unsignedp1;
+ int real1, real2;
+ tree primop0, primop1;
+ enum tree_code code = *rescode_ptr;
+
+ /* Throw away any conversions to wider types
+ already present in the operands. */
+
+ primop0 = get_narrower (op0, &unsignedp0);
+ primop1 = get_narrower (op1, &unsignedp1);
+
+ /* Handle the case that OP0 does not *contain* a conversion
+ but it *requires* conversion to FINAL_TYPE. */
+
+ if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
+ unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
+ if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
+ unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
+
+ /* If one of the operands must be floated, we cannot optimize. */
+ real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
+ real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
+
+ /* If first arg is constant, swap the args (changing operation
+ so value is preserved), for canonicalization. Don't do this if
+ the second arg is 0. */
+
+ if (TREE_CONSTANT (primop0)
+ && !integer_zerop (primop1) && !real_zerop (primop1))
+ {
+ tree tem = primop0;
+ int temi = unsignedp0;
+ primop0 = primop1;
+ primop1 = tem;
+ tem = op0;
+ op0 = op1;
+ op1 = tem;
+ *op0_ptr = op0;
+ *op1_ptr = op1;
+ unsignedp0 = unsignedp1;
+ unsignedp1 = temi;
+ temi = real1;
+ real1 = real2;
+ real2 = temi;
+
+ switch (code)
+ {
+ case LT_EXPR:
+ code = GT_EXPR;
+ break;
+ case GT_EXPR:
+ code = LT_EXPR;
+ break;
+ case LE_EXPR:
+ code = GE_EXPR;
+ break;
+ case GE_EXPR:
+ code = LE_EXPR;
+ break;
+ default:
+ break;
+ }
+ *rescode_ptr = code;
+ }
+
+ /* If comparing an integer against a constant more bits wide,
+ maybe we can deduce a value of 1 or 0 independent of the data.
+ Or else truncate the constant now
+ rather than extend the variable at run time.
+
+ This is only interesting if the constant is the wider arg.
+ Also, it is not safe if the constant is unsigned and the
+ variable arg is signed, since in this case the variable
+ would be sign-extended and then regarded as unsigned.
+ Our technique fails in this case because the lowest/highest
+ possible unsigned results don't follow naturally from the
+ lowest/highest possible values of the variable operand.
+ For just EQ_EXPR and NE_EXPR there is another technique that
+ could be used: see if the constant can be faithfully represented
+ in the other operand's type, by truncating it and reextending it
+ and see if that preserves the constant's value. */
+
+ if (!real1 && !real2
+ && TREE_CODE (primop1) == INTEGER_CST
+ && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
+ {
+ int min_gt, max_gt, min_lt, max_lt;
+ tree maxval, minval;
+ /* 1 if comparison is nominally unsigned. */
+ int unsignedp = TYPE_UNSIGNED (*restype_ptr);
+ tree val;
+
+ type = c_common_signed_or_unsigned_type2 (unsignedp0,
+ TREE_TYPE (primop0));
+
+ maxval = TYPE_MAX_VALUE (type);
+ minval = TYPE_MIN_VALUE (type);
+
+ if (unsignedp && !unsignedp0)
+ *restype_ptr = error_mark_node;
+/* c_common_signed_type (*restype_ptr); */
+
+ if (TREE_TYPE (primop1) != *restype_ptr)
+ {
+ /* Convert primop1 to target type, but do not introduce
+ additional overflow. We know primop1 is an int_cst. */
+ tree tmp = build_int_cst_wide (*restype_ptr,
+ TREE_INT_CST_LOW (primop1),
+ TREE_INT_CST_HIGH (primop1));
+
+ primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
+ TREE_CONSTANT_OVERFLOW (primop1));
+ }
+ if (type != *restype_ptr)
+ {
+ minval = convert2 (*restype_ptr, minval);
+ maxval = convert2 (*restype_ptr, maxval);
+ }
+
+ if (unsignedp && unsignedp0)
+ {
+ min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
+ max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
+ min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
+ max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
+ }
+ else
+ {
+ min_gt = INT_CST_LT (primop1, minval);
+ max_gt = INT_CST_LT (primop1, maxval);
+ min_lt = INT_CST_LT (minval, primop1);
+ max_lt = INT_CST_LT (maxval, primop1);
+ }
+
+ val = 0;
+ /* This used to be a switch, but Genix compiler can't handle that. */
+ if (code == NE_EXPR)
+ {
+ if (max_lt || min_gt)
+ val = error_mark_node; /* truthvalue_true_node; */
+ }
+ else if (code == EQ_EXPR)
+ {
+ if (max_lt || min_gt)
+ val = error_mark_node; /* truthvalue_false_node; */
+ }
+ else if (code == LT_EXPR)
+ {
+ if (max_lt)
+ val = error_mark_node; /* truthvalue_true_node; */
+ if (!min_lt)
+ val = error_mark_node; /* truthvalue_false_node; */
+ }
+ else if (code == GT_EXPR)
+ {
+ val = error_mark_node;
+/* if (min_gt) */
+/* val = truthvalue_true_node; */
+/* if (!max_gt) */
+/* val = truthvalue_false_node; */
+ }
+ else if (code == LE_EXPR)
+ {
+ val = error_mark_node;
+/* if (!max_gt) */
+/* val = truthvalue_true_node; */
+/* if (min_gt) */
+/* val = truthvalue_false_node; */
+ }
+ else if (code == GE_EXPR)
+ {
+ val = error_mark_node;
+/* if (!min_lt) */
+/* val = truthvalue_true_node; */
+/* if (max_lt) */
+/* val = truthvalue_false_node; */
+ }
+
+ /* If primop0 was sign-extended and unsigned comparison specd,
+ we did a signed comparison above using the signed type bounds.
+ But the comparison we output must be unsigned.
+
+ Also, for inequalities, VAL is no good; but if the signed
+ comparison had *any* fixed result, it follows that the
+ unsigned comparison just tests the sign in reverse
+ (positive values are LE, negative ones GE).
+ So we can generate an unsigned comparison
+ against an extreme value of the signed type. */
+
+ if (unsignedp && !unsignedp0)
+ {
+ if (val != 0)
+ switch (code)
+ {
+ case LT_EXPR:
+ case GE_EXPR:
+ primop1 = TYPE_MIN_VALUE (type);
+ val = 0;
+ break;
+
+ case LE_EXPR:
+ case GT_EXPR:
+ primop1 = TYPE_MAX_VALUE (type);
+ val = 0;
+ break;
+
+ default:
+ break;
+ }
+ type = error_mark_node;
+ /* c_common_unsigned_type (type); */
+ }
+
+ if (TREE_CODE (primop0) != INTEGER_CST)
+ {
+/* if (val == truthvalue_false_node) */
+/* warning (0, "comparison is always false due to limited range of data type"); */
+/* if (val == truthvalue_true_node) */
+/* warning (0, "comparison is always true due to limited range of data type"); */
+ }
+
+ if (val != 0)
+ {
+ /* Don't forget to evaluate PRIMOP0 if it has side effects. */
+ if (TREE_SIDE_EFFECTS (primop0))
+ return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
+ return val;
+ }
+
+ /* Value is not predetermined, but do the comparison
+ in the type of the operand that is not constant.
+ TYPE is already properly set. */
+ }
+
+ /* If either arg is decimal float and the other is float, find the
+ proper common type to use for comparison. */
+ else if (real1 && real2
+ && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
+ || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
+ type = error_mark_node;
+ /* common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); */
+
+ else if (real1 && real2
+ && (TYPE_PRECISION (TREE_TYPE (primop0))
+ == TYPE_PRECISION (TREE_TYPE (primop1))))
+ type = TREE_TYPE (primop0);
+
+ /* If args' natural types are both narrower than nominal type
+ and both extend in the same manner, compare them
+ in the type of the wider arg.
+ Otherwise must actually extend both to the nominal
+ common type lest different ways of extending
+ alter the result.
+ (eg, (short)-1 == (unsigned short)-1 should be 0.) */
+
+ else if (unsignedp0 == unsignedp1 && real1 == real2
+ && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
+ && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
+ {
+ type = error_mark_node;
+ /* common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); */
+ type = error_mark_node;
+ /* c_common_signed_or_unsigned_type (unsignedp0 */
+/* || TYPE_UNSIGNED (*restype_ptr), */
+/* type); */
+ /* Make sure shorter operand is extended the right way
+ to match the longer operand. */
+ primop0
+ = convert2 (error_mark_node,
+ /* c_common_signed_or_unsigned_type (unsignedp0, */
+/* TREE_TYPE (primop0)), */
+ primop0);
+ primop1
+ = convert2 (error_mark_node,
+/* c_common_signed_or_unsigned_type (unsignedp1, */
+/* TREE_TYPE (primop1)), */
+ primop1);
+ }
+ else
+ {
+ /* Here we must do the comparison on the nominal type
+ using the args exactly as we received them. */
+ type = *restype_ptr;
+ primop0 = op0;
+ primop1 = op1;
+
+ if (!real1 && !real2 && integer_zerop (primop1)
+ && TYPE_UNSIGNED (*restype_ptr))
+ {
+ tree value = 0;
+ switch (code)
+ {
+ case GE_EXPR:
+ /* All unsigned values are >= 0, so we warn if extra warnings
+ are requested. However, if OP0 is a constant that is
+ >= 0, the signedness of the comparison isn't an issue,
+ so suppress the warning. */
+ if (extra_warnings && !in_system_header
+ && !(TREE_CODE (primop0) == INTEGER_CST
+ && !TREE_OVERFLOW (convert2 (error_mark_node,
+/* c_common_signed_type (type), */
+ primop0))))
+ warning (0, "comparison of unsigned expression >= 0 is always true");
+ value = error_mark_node; /* truthvalue_true_node; */
+ break;
+
+ case LT_EXPR:
+ if (extra_warnings && !in_system_header
+ && !(TREE_CODE (primop0) == INTEGER_CST
+ && !TREE_OVERFLOW (convert2 (error_mark_node,
+/* c_common_signed_type (type), */
+ primop0))))
+ warning (0, "comparison of unsigned expression < 0 is always false");
+ value = error_mark_node; /* truthvalue_false_node; */
+ break;
+
+ default:
+ break;
+ }
+
+ if (value != 0)
+ {
+ /* Don't forget to evaluate PRIMOP0 if it has side effects. */
+ if (TREE_SIDE_EFFECTS (primop0))
+ return build2 (COMPOUND_EXPR, TREE_TYPE (value),
+ primop0, value);
+ return value;
+ }
+ }
+ }
+
+ *op0_ptr = convert2 (type, primop0);
+ *op1_ptr = convert2 (type, primop1);
+
+ *restype_ptr = error_mark_node; /* truthvalue_type_node; */
+
+ return 0;
+}
+
+static tree
+common_truthvalue_conversion (tree expr);
+
+#define TYPE_PTRMEMFUNC_P(NODE) \
+ (TREE_CODE (NODE) == RECORD_TYPE \
+ && TYPE_LANG_SPECIFIC (NODE))
+
+static bool
+null_ptr_cst_p2 (tree t ATTRIBUTE_UNUSED)
+{
+ /* [conv.ptr]
+
+ A null pointer constant is an integral constant expression
+ (_expr.const_) rvalue of integer type that evaluates to zero. */
+
+ return true;
+/* t = integral_constant_value (t); */
+/* if (t == null_node */
+/* || (CP_INTEGRAL_TYPE_P (TREE_TYPE (t)) && integer_zerop (t))) */
+/* return true; */
+/* return false; */
+}
+
+
+
+static tree
+build_binary_op2 (enum tree_code code, tree orig_op0, tree orig_op1,
+ int convert_p ATTRIBUTE_UNUSED)
+{
+
+ /*<hack>*/
+ int skip_evaluation = 1;
+ /*<hack>*/
+
+ tree type0, type1;
+ enum tree_code code0, code1;
+ tree op0, op1;
+/* const char *invalid_op_diag; */
+
+ /* Expression code to give to the expression when it is built.
+ Normally this is CODE, which is what the caller asked for,
+ but in some special cases we change it. */
+ enum tree_code resultcode = code;
+
+ /* Data type in which the computation is to be performed.
+ In the simplest cases this is the common type of the arguments. */
+ tree result_type = NULL;
+
+ /* Nonzero means operands have already been type-converted
+ in whatever way is necessary.
+ Zero means they need to be converted to RESULT_TYPE. */
+ int converted = 0;
+
+ /* Nonzero means create the expression with this type, rather than
+ RESULT_TYPE. */
+ tree build_type = 0;
+
+ /* Nonzero means after finally constructing the expression
+ convert it to this type. */
+ tree final_type = 0;
+
+ /* Nonzero if this is an operation like MIN or MAX which can
+ safely be computed in short if both args are promoted shorts.
+ Also implies COMMON.
+ -1 indicates a bitwise operation; this makes a difference
+ in the exact conditions for when it is safe to do the operation
+ in a narrower mode. */
+ int shorten = 0;
+
+ /* Nonzero if this is a comparison operation;
+ if both args are promoted shorts, compare the original shorts.
+ Also implies COMMON. */
+ int short_compare = 0;
+
+ /* Nonzero if this is a right-shift operation, which can be computed on the
+ original short and then promoted if the operand is a promoted short. */
+ int short_shift = 0;
+
+ /* Nonzero means set RESULT_TYPE to the common type of the args. */
+ int common = 0;
+
+ /* True means types are compatible as far as ObjC is concerned. */
+/* bool objc_ok; */
+
+ if (convert_p)
+ {
+ op0 = default_conversion2 (orig_op0);
+ op1 = default_conversion2 (orig_op1);
+ }
+ else
+ {
+ op0 = orig_op0;
+ op1 = orig_op1;
+ }
+
+ type0 = TREE_TYPE (op0);
+ type1 = TREE_TYPE (op1);
+
+ /* The expression codes of the data types of the arguments tell us
+ whether the arguments are integers, floating, pointers, etc. */
+ code0 = TREE_CODE (type0);
+ code1 = TREE_CODE (type1);
+
+ /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */
+ STRIP_TYPE_NOPS (op0);
+ STRIP_TYPE_NOPS (op1);
+
+ /* If an error was already reported for one of the arguments,
+ avoid reporting another error. */
+
+ if (code0 == ERROR_MARK || code1 == ERROR_MARK)
+ return error_mark_node;
+
+/* if ((invalid_op_diag */
+/* = targetm.invalid_binary_op (code, type0, type1))) */
+/* { */
+/* error (invalid_op_diag); */
+/* return error_mark_node; */
+/* } */
+
+/* objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE); */
+
+ switch (code)
+ {
+ case PLUS_EXPR:
+ /* Handle the pointer + int case. */
+ if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+ return error_mark_node;
+/* pointer_int_sum (PLUS_EXPR, op0, op1); */
+ else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
+ return error_mark_node;
+/* pointer_int_sum (PLUS_EXPR, op1, op0); */
+ else
+ common = 1;
+ break;
+
+ case MINUS_EXPR:
+ /* Subtraction of two similar pointers.
+ We must subtract them as integers, then divide by object size. */
+
+ if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
+ && 1)
+/* comp_target_types (type0, type1)) */
+ return error_mark_node;
+ /* pointer_diff (op0, op1); */
+
+/* Handle pointer minus int. Just like pointer plus int. */
+ else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+ return error_mark_node;
+/* pointer_int_sum (MINUS_EXPR, op0, op1); */
+ else
+ common = 1;
+ break;
+
+ case MULT_EXPR:
+ common = 1;
+ break;
+
+ case TRUNC_DIV_EXPR:
+ case CEIL_DIV_EXPR:
+ case FLOOR_DIV_EXPR:
+ case ROUND_DIV_EXPR:
+ case EXACT_DIV_EXPR:
+ /* Floating point division by zero is a legitimate way to obtain
+ infinities and NaNs. */
+ if (skip_evaluation == 0 && integer_zerop (op1))
+ warning (OPT_Wdiv_by_zero, "division by zero");
+
+ if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+ || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
+ && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+ || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
+ {
+ enum tree_code tcode0 = code0, tcode1 = code1;
+
+ if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
+ tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
+ if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
+ tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
+
+ if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
+ resultcode = RDIV_EXPR;
+ else
+ /* Although it would be tempting to shorten always here, that
+ loses on some targets, since the modulo instruction is
+ undefined if the quotient can't be represented in the
+ computation mode. We shorten only if unsigned or if
+ dividing by something we know != -1. */
+ shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && !integer_all_onesp (op1)));
+ common = 1;
+ }
+ break;
+
+ case BIT_AND_EXPR:
+ case BIT_IOR_EXPR:
+ case BIT_XOR_EXPR:
+ if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ shorten = -1;
+ else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
+ common = 1;
+ break;
+
+ case TRUNC_MOD_EXPR:
+ case FLOOR_MOD_EXPR:
+ if (skip_evaluation == 0 && integer_zerop (op1))
+ warning (OPT_Wdiv_by_zero, "division by zero");
+
+ if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ {
+ /* Although it would be tempting to shorten always here, that loses
+ on some targets, since the modulo instruction is undefined if the
+ quotient can't be represented in the computation mode. We shorten
+ only if unsigned or if dividing by something we know != -1. */
+ shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
+ || (TREE_CODE (op1) == INTEGER_CST
+ && !integer_all_onesp (op1)));
+ common = 1;
+ }
+ break;
+
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case TRUTH_AND_EXPR:
+ case TRUTH_OR_EXPR:
+ case TRUTH_XOR_EXPR:
+ if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
+ || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
+ && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
+ || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
+ {
+ /* Result of these operations is always an int,
+ but that does not mean the operands should be
+ converted to ints! */
+ result_type = integer_type_node;
+ op0 = common_truthvalue_conversion (op0);
+ op1 = common_truthvalue_conversion (op1);
+ converted = 1;
+ }
+ break;
+
+ /* Shift operations: result has same type as first operand;
+ always convert second operand to int.
+ Also set SHORT_SHIFT if shifting rightward. */
+
+ case RSHIFT_EXPR:
+ if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ {
+ if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
+ {
+ if (tree_int_cst_sgn (op1) < 0)
+ warning (0, "right shift count is negative");
+ else
+ {
+ if (!integer_zerop (op1))
+ short_shift = 1;
+
+ if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
+ warning (0, "right shift count >= width of type");
+ }
+ }
+
+ /* Use the type of the value to be shifted. */
+ result_type = type0;
+ /* Convert the shift-count to an integer, regardless of size
+ of value being shifted. */
+ if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+ op1 = convert2 (integer_type_node, op1);
+ /* Avoid converting op1 to result_type later. */
+ converted = 1;
+ }
+ break;
+
+ case LSHIFT_EXPR:
+ if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
+ {
+ if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
+ {
+ if (tree_int_cst_sgn (op1) < 0)
+ warning (0, "left shift count is negative");
+
+ else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
+ warning (0, "left shift count >= width of type");
+ }
+
+ /* Use the type of the value to be shifted. */
+ result_type = type0;
+ /* Convert the shift-count to an integer, regardless of size
+ of value being shifted. */
+ if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
+ op1 = convert2 (integer_type_node, op1);
+ /* Avoid converting op1 to result_type later. */
+ converted = 1;
+ }
+ break;
+
+ case EQ_EXPR:
+ case NE_EXPR:
+ if (code0 == REAL_TYPE || code1 == REAL_TYPE)
+ warning (OPT_Wfloat_equal,
+ "comparing floating point with == or != is unsafe");
+ /* Result of comparison is always int,
+ but don't convert the args to int! */
+ build_type = integer_type_node;
+ if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
+ || code0 == COMPLEX_TYPE)
+ && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
+ || code1 == COMPLEX_TYPE))
+ short_compare = 1;
+ else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+ {
+ tree tt0 = TREE_TYPE (type0);
+ tree tt1 = TREE_TYPE (type1);
+ /* Anything compares with void *. void * compares with anything.
+ Otherwise, the targets must be compatible
+ and both must be object or both incomplete. */
+/* if (comp_target_types (type0, type1)) */
+/* result_type = common_pointer_type (type0, type1); */
+/* else */
+ if (VOID_TYPE_P (tt0))
+ {
+ /* op0 != orig_op0 detects the case of something
+ whose value is 0 but which isn't a valid null ptr const. */
+/* if (pedantic && !null_pointer_constant_p (orig_op0) */
+/* && TREE_CODE (tt1) == FUNCTION_TYPE) */
+/* pedwarn ("ISO C forbids comparison of %<void *%>" */
+/* " with function pointer"); */
+ }
+ else if (VOID_TYPE_P (tt1))
+ {
+/* if (pedantic && !null_pointer_constant_p (orig_op1) */
+/* && TREE_CODE (tt0) == FUNCTION_TYPE) */
+/* pedwarn ("ISO C forbids comparison of %<void *%>" */
+/* " with function pointer"); */
+ }
+ else
+ /* Avoid warning about the volatile ObjC EH puts on decls. */
+/* if (!objc_ok) */
+/* pedwarn ("comparison of distinct pointer types lacks a cast"); */
+
+ if (result_type == NULL_TREE)
+ result_type = ptr_type_node;
+ }
+/* else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) */
+/* { */
+/* if (TREE_CODE (op0) == ADDR_EXPR */
+/* && DECL_P (TREE_OPERAND (op0, 0)) */
+/* && !DECL_WEAK (TREE_OPERAND (op0, 0))) */
+/* warning (OPT_Walways_true, "the address of %qD will never be NULL", */
+/* TREE_OPERAND (op0, 0)); */
+/* result_type = type0; */
+/* } */
+/* else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) */
+/* { */
+/* if (TREE_CODE (op1) == ADDR_EXPR */
+/* && DECL_P (TREE_OPERAND (op1, 0)) */
+/* && !DECL_WEAK (TREE_OPERAND (op1, 0))) */
+/* warning (OPT_Walways_true, "the address of %qD will never be NULL", */
+/* TREE_OPERAND (op1, 0)); */
+/* result_type = type1; */
+/* } */
+ else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+ {
+ result_type = type0;
+/* pedwarn ("comparison between pointer and integer"); */
+ }
+ else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
+ {
+ result_type = type1;
+/* pedwarn ("comparison between pointer and integer"); */
+ }
+ else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p2 (op1)) /* c++ */
+ {
+ op0 = op0; /* build_ptrmemfunc_access_expr (op0, pfn_identifier); */
+ op1 = convert2 (TREE_TYPE (op0), integer_zero_node);
+ result_type = TREE_TYPE (op0);
+ }
+ break;
+
+ case LE_EXPR:
+ case GE_EXPR:
+ case LT_EXPR:
+ case GT_EXPR:
+ build_type = integer_type_node;
+ if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
+ && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
+ short_compare = 1;
+ else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
+ {
+/* if (comp_target_types (type0, type1)) */
+/* { */
+/* result_type = common_pointer_type (type0, type1); */
+/* if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) */
+/* != !COMPLETE_TYPE_P (TREE_TYPE (type1))) */
+/* pedwarn ("comparison of complete and incomplete pointers"); */
+/* else if (pedantic */
+/* && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) */
+/* pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); */
+/* } */
+/* else */
+ {
+ result_type = ptr_type_node;
+ pedwarn ("comparison of distinct pointer types lacks a cast");
+ }
+ }
+/* else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) */
+/* { */
+/* result_type = type0; */
+/* if (pedantic || extra_warnings) */
+/* pedwarn ("ordered comparison of pointer with integer zero"); */
+/* } */
+/* else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) */
+/* { */
+/* result_type = type1; */
+/* if (pedantic) */
+/* pedwarn ("ordered comparison of pointer with integer zero"); */
+/* } */
+ else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
+ {
+ result_type = type0;
+ pedwarn ("comparison between pointer and integer");
+ }
+ else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
+ {
+ result_type = type1;
+ pedwarn ("comparison between pointer and integer");
+ }
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ if (code0 == ERROR_MARK || code1 == ERROR_MARK)
+ return error_mark_node;
+
+ if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
+ && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
+ || 0))
+/* !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), */
+/* TREE_TYPE (type1)))) */
+ {
+/* binary_op_error (code); */
+ return error_mark_node;
+ }
+
+ if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
+ || code0 == VECTOR_TYPE)
+ &&
+ (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
+ || code1 == VECTOR_TYPE))
+ {
+ int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
+
+ if (shorten || common || short_compare)
+ result_type = c_common_type (type0, type1);
+
+ /* For certain operations (which identify themselves by shorten != 0)
+ if both args were extended from the same smaller type,
+ do the arithmetic in that type and then extend.
+
+ shorten !=0 and !=1 indicates a bitwise operation.
+ For them, this optimization is safe only if
+ both args are zero-extended or both are sign-extended.
+ Otherwise, we might change the result.
+ Eg, (short)-1 | (unsigned short)-1 is (int)-1
+ but calculated in (unsigned short) it would be (unsigned short)-1. */
+
+ if (shorten && none_complex)
+ {
+ int unsigned0, unsigned1;
+ tree arg0, arg1;
+ int uns;
+ tree type;
+
+ /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents
+ excessive narrowing when we call get_narrower below. For
+ example, suppose that OP0 is of unsigned int extended
+ from signed char and that RESULT_TYPE is long long int.
+ If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
+ like
+
+ (long long int) (unsigned int) signed_char
+
+ which get_narrower would narrow down to
+
+ (unsigned int) signed char
+
+ If we do not cast OP0 first, get_narrower would return
+ signed_char, which is inconsistent with the case of the
+ explicit cast. */
+ op0 = convert2 (result_type, op0);
+ op1 = convert2 (result_type, op1);
+
+ arg0 = get_narrower (op0, &unsigned0);
+ arg1 = get_narrower (op1, &unsigned1);
+
+ /* UNS is 1 if the operation to be done is an unsigned one. */
+ uns = TYPE_UNSIGNED (result_type);
+
+ final_type = result_type;
+
+ /* Handle the case that OP0 (or OP1) does not *contain* a conversion
+ but it *requires* conversion to FINAL_TYPE. */
+
+ if ((TYPE_PRECISION (TREE_TYPE (op0))
+ == TYPE_PRECISION (TREE_TYPE (arg0)))
+ && TREE_TYPE (op0) != final_type)
+ unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
+ if ((TYPE_PRECISION (TREE_TYPE (op1))
+ == TYPE_PRECISION (TREE_TYPE (arg1)))
+ && TREE_TYPE (op1) != final_type)
+ unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
+
+ /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */
+
+ /* For bitwise operations, signedness of nominal type
+ does not matter. Consider only how operands were extended. */
+ if (shorten == -1)
+ uns = unsigned0;
+
+ /* Note that in all three cases below we refrain from optimizing
+ an unsigned operation on sign-extended args.
+ That would not be valid. */
+
+ /* Both args variable: if both extended in same way
+ from same width, do it in that width.
+ Do it unsigned if args were zero-extended. */
+ if ((TYPE_PRECISION (TREE_TYPE (arg0))
+ < TYPE_PRECISION (result_type))
+ && (TYPE_PRECISION (TREE_TYPE (arg1))
+ == TYPE_PRECISION (TREE_TYPE (arg0)))
+ && unsigned0 == unsigned1
+ && (unsigned0 || !uns))
+ result_type
+ = error_mark_node;
+ /* c_common_signed_or_unsigned_type */
+/* (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); */
+ else if (TREE_CODE (arg0) == INTEGER_CST
+ && (unsigned1 || !uns)
+ && (TYPE_PRECISION (TREE_TYPE (arg1))
+ < TYPE_PRECISION (result_type))
+ && (type
+ = error_mark_node,
+/* c_common_signed_or_unsigned_type (unsigned1, */
+/* TREE_TYPE (arg1)), */
+ int_fits_type_p (arg0, type)))
+ result_type = type;
+ else if (TREE_CODE (arg1) == INTEGER_CST
+ && (unsigned0 || !uns)
+ && (TYPE_PRECISION (TREE_TYPE (arg0))
+ < TYPE_PRECISION (result_type))
+ && (type
+ = error_mark_node,
+/* c_common_signed_or_unsigned_type (unsigned0, */
+/* TREE_TYPE (arg0)), */
+ int_fits_type_p (arg1, type)))
+ result_type = type;
+ }
+
+ /* Shifts can be shortened if shifting right. */
+
+ if (short_shift)
+ {
+ int unsigned_arg;
+ tree arg0 = get_narrower (op0, &unsigned_arg);
+
+ final_type = result_type;
+
+ if (arg0 == op0 && final_type == TREE_TYPE (op0))
+ unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
+
+ if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
+ /* We can shorten only if the shift count is less than the
+ number of bits in the smaller type size. */
+ && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
+ /* We cannot drop an unsigned shift after sign-extension. */
+ && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
+ {
+ /* Do an unsigned shift if the operand was zero-extended. */
+ result_type
+ = error_mark_node;
+/* c_common_signed_or_unsigned_type (unsigned_arg, */
+/* TREE_TYPE (arg0)); */
+ /* Convert value-to-be-shifted to that type. */
+ if (TREE_TYPE (op0) != result_type)
+ op0 = convert2 (result_type, op0);
+ converted = 1;
+ }
+ }
+
+ /* Comparison operations are shortened too but differently.
+ They identify themselves by setting short_compare = 1. */
+
+ if (short_compare)
+ {
+ /* Don't write &op0, etc., because that would prevent op0
+ from being kept in a register.
+ Instead, make copies of the our local variables and
+ pass the copies by reference, then copy them back afterward. */
+ tree xop0 = op0, xop1 = op1, xresult_type = result_type;
+ enum tree_code xresultcode = resultcode;
+ tree val =
+ shorten_compare2 (&xop0, &xop1, &xresult_type, &xresultcode);
+
+ if (val != 0)
+ return val;
+
+ op0 = xop0, op1 = xop1;
+ converted = 1;
+ resultcode = xresultcode;
+
+ if (warn_sign_compare && skip_evaluation == 0)
+ {
+ int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
+ int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
+ int unsignedp0, unsignedp1;
+ tree primop0 = get_narrower (op0, &unsignedp0);
+ tree primop1 = get_narrower (op1, &unsignedp1);
+
+ xop0 = orig_op0;
+ xop1 = orig_op1;
+ STRIP_TYPE_NOPS (xop0);
+ STRIP_TYPE_NOPS (xop1);
+
+ /* Give warnings for comparisons between signed and unsigned
+ quantities that may fail.
+
+ Do the checking based on the original operand trees, so that
+ casts will be considered, but default promotions won't be.
+
+ Do not warn if the comparison is being done in a signed type,
+ since the signed type will only be chosen if it can represent
+ all the values of the unsigned type. */
+ if (!TYPE_UNSIGNED (result_type))
+ /* OK */;
+ /* Do not warn if both operands are the same signedness. */
+ else if (op0_signed == op1_signed)
+ /* OK */;
+ else
+ {
+ tree sop, uop;
+
+ if (op0_signed)
+ sop = xop0, uop = xop1;
+ else
+ sop = xop1, uop = xop0;
+
+ /* Do not warn if the signed quantity is an
+ unsuffixed integer literal (or some static
+ constant expression involving such literals or a
+ conditional expression involving such literals)
+ and it is non-negative. */
+ if (tree_expr_nonnegative_p (sop))
+ /* OK */;
+ /* Do not warn if the comparison is an equality operation,
+ the unsigned quantity is an integral constant, and it
+ would fit in the result if the result were signed. */
+ else if (TREE_CODE (uop) == INTEGER_CST
+ && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
+ && int_fits_type_p
+ (uop, error_mark_node))
+ /* c_common_signed_type (result_type))) */
+ /* OK */;
+ /* Do not warn if the unsigned quantity is an enumeration
+ constant and its maximum value would fit in the result
+ if the result were signed. */
+ else if (TREE_CODE (uop) == INTEGER_CST
+ && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
+ && int_fits_type_p
+ (TYPE_MAX_VALUE (TREE_TYPE (uop)),
+ error_mark_node))
+/* c_common_signed_type (result_type))) */
+ /* OK */;
+ else
+ warning (0, "comparison between signed and unsigned");
+ }
+
+ /* Warn if two unsigned values are being compared in a size
+ larger than their original size, and one (and only one) is the
+ result of a `~' operator. This comparison will always fail.
+
+ Also warn if one operand is a constant, and the constant
+ does not have all bits set that are set in the ~ operand
+ when it is extended. */
+
+ if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
+ != (TREE_CODE (primop1) == BIT_NOT_EXPR))
+ {
+ if (TREE_CODE (primop0) == BIT_NOT_EXPR)
+ primop0 = get_narrower (TREE_OPERAND (primop0, 0),
+ &unsignedp0);
+ else
+ primop1 = get_narrower (TREE_OPERAND (primop1, 0),
+ &unsignedp1);
+
+ if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
+ {
+ tree primop;
+ HOST_WIDE_INT constant, mask;
+ int unsignedp, bits;
+
+ if (host_integerp (primop0, 0))
+ {
+ primop = primop1;
+ unsignedp = unsignedp1;
+ constant = tree_low_cst (primop0, 0);
+ }
+ else
+ {
+ primop = primop0;
+ unsignedp = unsignedp0;
+ constant = tree_low_cst (primop1, 0);
+ }
+
+ bits = TYPE_PRECISION (TREE_TYPE (primop));
+ if (bits < TYPE_PRECISION (result_type)
+ && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
+ {
+ mask = (~(HOST_WIDE_INT) 0) << bits;
+ if ((mask & constant) != mask)
+ warning (0, "comparison of promoted ~unsigned with constant");
+ }
+ }
+ else if (unsignedp0 && unsignedp1
+ && (TYPE_PRECISION (TREE_TYPE (primop0))
+ < TYPE_PRECISION (result_type))
+ && (TYPE_PRECISION (TREE_TYPE (primop1))
+ < TYPE_PRECISION (result_type)))
+ warning (0, "comparison of promoted ~unsigned with unsigned");
+ }
+ }
+ }
+ }
+
+ /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
+ If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
+ Then the expression will be built.
+ It will be given type FINAL_TYPE if that is nonzero;
+ otherwise, it will be given type RESULT_TYPE. */
+
+ if (!result_type)
+ {
+/* binary_op_error (code); */
+ return error_mark_node;
+ }
+
+ if (!converted)
+ {
+ if (TREE_TYPE (op0) != result_type)
+ op0 = convert2 (result_type, op0);
+ if (TREE_TYPE (op1) != result_type)
+ op1 = convert2 (result_type, op1);
+
+ /* This can happen if one operand has a vector type, and the other
+ has a different type. */
+ if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
+ return error_mark_node;
+ }
+
+ if (build_type == NULL_TREE)
+ build_type = result_type;
+
+ {
+ /* Treat expressions in initializers specially as they can't trap. */
+ int require_constant_value = 0;
+ tree result = require_constant_value ? fold_build2_initializer (resultcode,
+ build_type,
+ op0, op1)
+ : fold_build2 (resultcode, build_type,
+ op0, op1);
+
+ if (final_type != 0)
+ result = convert2 (final_type, result);
+ return result;
+ }
+}
+
+/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
+ or for an `if' or `while' statement or ?..: exp. It should already
+ have been validated to be of suitable type; otherwise, a bad
+ diagnostic may result.
+
+ This preparation consists of taking the ordinary
+ representation of an expression expr and producing a valid tree
+ boolean expression describing whether expr is nonzero. We could
+ simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
+ but we optimize comparisons, &&, ||, and !.
+
+ The resulting type should always be `truthvalue_type_node'. */
+
+static tree
+common_truthvalue_conversion2 (tree expr)
+{
+
+ switch (TREE_CODE (expr))
+ {
+ case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
+ case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
+ case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
+ case ORDERED_EXPR: case UNORDERED_EXPR:
+ if (TREE_TYPE (expr) == integer_type_node)
+ return expr;
+ return build2 (TREE_CODE (expr), integer_type_node,
+ TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
+
+ case TRUTH_ANDIF_EXPR:
+ case TRUTH_ORIF_EXPR:
+ case TRUTH_AND_EXPR:
+ case TRUTH_OR_EXPR:
+ case TRUTH_XOR_EXPR:
+ if (TREE_TYPE (expr) == integer_type_node)
+ return expr;
+ return build2 (TREE_CODE (expr), integer_type_node,
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 0)),
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 1)));
+
+ case TRUTH_NOT_EXPR:
+ if (TREE_TYPE (expr) == integer_type_node)
+ return expr;
+ return build1 (TREE_CODE (expr), integer_type_node,
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 0)));
+
+ case ERROR_MARK:
+ return expr;
+
+ case INTEGER_CST:
+ /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
+ return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
+ ? integer_one_node
+ : integer_zero_node;
+
+ case REAL_CST:
+ return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
+ ? integer_one_node
+ : integer_zero_node;
+
+/* case FUNCTION_DECL: */
+/* expr = build_unary_op (ADDR_EXPR, expr, 0); */
+ /* Fall through. */
+
+ case ADDR_EXPR:
+ {
+ tree inner = TREE_OPERAND (expr, 0);
+ if (DECL_P (inner)
+ && (TREE_CODE (inner) == PARM_DECL || !DECL_WEAK (inner)))
+ {
+ /* Common Ada/Pascal programmer's mistake. We always warn
+ about this since it is so bad. */
+ warning (OPT_Walways_true, "the address of %qD, will always evaluate as %<true%>",
+ inner);
+ return integer_one_node;
+ }
+
+ /* If we are taking the address of an external decl, it might be
+ zero if it is weak, so we cannot optimize. */
+ if (DECL_P (inner)
+ && DECL_EXTERNAL (inner))
+ break;
+
+ if (TREE_SIDE_EFFECTS (inner))
+ return build2 (COMPOUND_EXPR, integer_type_node,
+ inner, integer_one_node);
+ else
+ return integer_one_node;
+ }
+
+/* case COMPLEX_EXPR: */
+/* return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) */
+/* ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), */
+/* common_truthvalue_conversion2 (TREE_OPERAND (expr, 0)), */
+/* common_truthvalue_conversion2 (TREE_OPERAND (expr, 1)), */
+/* 0); */
+
+ case NEGATE_EXPR:
+ case ABS_EXPR:
+ case FLOAT_EXPR:
+ /* These don't change whether an object is nonzero or zero. */
+ return common_truthvalue_conversion2 (TREE_OPERAND (expr, 0));
+
+ case LROTATE_EXPR:
+ case RROTATE_EXPR:
+ /* These don't change whether an object is zero or nonzero, but
+ we can't ignore them if their second arg has side-effects. */
+ if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
+ return build2 (COMPOUND_EXPR, integer_type_node,
+ TREE_OPERAND (expr, 1),
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 0)));
+ else
+ return common_truthvalue_conversion2 (TREE_OPERAND (expr, 0));
+
+ case COND_EXPR:
+ /* Distribute the conversion into the arms of a COND_EXPR. */
+ return fold_build3 (COND_EXPR, integer_type_node,
+ TREE_OPERAND (expr, 0),
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 1)),
+ common_truthvalue_conversion2 (TREE_OPERAND (expr, 2)));
+
+ case CONVERT_EXPR:
+ case NOP_EXPR:
+ /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
+ since that affects how `default_conversion' will behave. */
+ if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
+ || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
+ break;
+ /* If this is widening the argument, we can ignore it. */
+ if (TYPE_PRECISION (TREE_TYPE (expr))
+ >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
+ return common_truthvalue_conversion2 (TREE_OPERAND (expr, 0));
+ break;
+
+ case MODIFY_EXPR:
+ if (!TREE_NO_WARNING (expr))
+ warning (OPT_Wparentheses,
+ "suggest parentheses around assignment used as truth value");
+ break;
+
+ default:
+ break;
+ }
+
+ if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
+ {
+ return error_mark_node;
+/* tree t = save_expr (expr); */
+/* return (build_binary_op */
+/* ((TREE_SIDE_EFFECTS (expr) */
+/* ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), */
+/* common_truthvalue_conversion2 (build_unary_op (REALPART_EXPR, t, 0)), */
+/* common_truthvalue_conversion2 (build_unary_op (IMAGPART_EXPR, t, 0)), */
+/* 0)); */
+ }
+
+ {
+/* enum tree_code code = TREE_CODE(expr); */
+/* if (code == CALL_EXPR) */
+/* return error_mark_node; */
+/* if (code == PARM_DECL) */
+/* return error_mark_node; */
+/* if (code == VAR_DECL) */
+/* return error_mark_node; */
+/* if (code == ARRAY_REF) */
+/* return error_mark_node; */
+/* if (code == COMPONENT_REF) */
+/* return error_mark_node; */
+/* if (code == BIT_AND_EXPR) */
+/* return error_mark_node; */
+/* if (code == COMPOUND_EXPR) */
+/* return error_mark_node; */
+ }
+/* printf("\n\n"); */
+/* debug_tree(expr); */
+/* printf("\n\n"); */
+
+ return build_binary_op2 (NE_EXPR, expr, integer_zero_node, 1);
+}
+
+/* Convert EXPR to be a truth-value, validating its type for this
+ purpose. */
+
+static tree
+common_truthvalue_conversion (tree expr)
+{
+ switch (TREE_CODE (TREE_TYPE (expr)))
+ {
+ case ARRAY_TYPE:
+ error ("used array that cannot be converted to pointer where scalar is required");
+ return error_mark_node;
+
+/* case RECORD_TYPE: */
+/* error ("used struct type value where scalar is required"); */
+/* return error_mark_node; */
+
+ case UNION_TYPE:
+ error ("used union type value where scalar is required");
+ return error_mark_node;
+
+ case FUNCTION_TYPE:
+ gcc_unreachable ();
+
+ default:
+ break;
+ }
+
+ /* ??? Should we also give an error for void and vectors rather than
+ leaving those to give errors later? */
+ return common_truthvalue_conversion2 (expr);
+}
+
+#define TYPE_PTRMEM_P(NODE) \
+ (TREE_CODE (NODE) == OFFSET_TYPE)
+
+tree
+convert2 (tree type, tree expr)
+{
+ tree e = expr;
+ enum tree_code code = TREE_CODE (type);
+ tree texpr;
+ /* const char *invalid_conv_diag; */
+
+ if (type == error_mark_node
+ || expr == error_mark_node
+ || TREE_TYPE (expr) == error_mark_node)
+ return error_mark_node;
+
+/* if ((invalid_conv_diag */
+/* = targetm.invalid_conversion (TREE_TYPE (expr), type))) */
+/* { */
+/* error (invalid_conv_diag); */
+/* return error_mark_node; */
+/* } */
+
+ texpr = TREE_TYPE (expr);
+ if (type == texpr)
+ return expr;
+
+ if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
+ return fold_convert (type, expr);
+ if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
+ return error_mark_node;
+ if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
+ {
+ error ("void value not ignored as it ought to be");
+ return error_mark_node;
+ }
+ if (code == VOID_TYPE)
+ return fold_convert (type, e);
+ if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
+ return fold (convert_to_integer (type, e));
+ if (code == BOOLEAN_TYPE) {
+ tree aux = common_truthvalue_conversion (expr);
+ if (aux != error_mark_node)
+ return fold_convert (type, aux);
+ }
+
+ if (POINTER_TYPE_P (type))
+ return fold (convert_to_pointer (type, e));
+ if (TYPE_PTRMEM_P (type))
+ gcc_unreachable();
+ if (TYPE_PTRMEMFUNC_P (type))
+ gcc_unreachable();
+
+ if (code == REAL_TYPE)
+ return fold (convert_to_real (type, e));
+ if (code == COMPLEX_TYPE)
+ return fold (convert_to_complex (type, e));
+ if (code == VECTOR_TYPE)
+ return fold (convert_to_vector (type, e));
+ if ((code == RECORD_TYPE || code == UNION_TYPE)
+ && lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
+ return e;
+
+ error ( "conversion to non-scalar type requested");
+ return error_mark_node;
+}
Index: gcc/c-typeck.c
===================================================================
--- gcc/c-typeck.c (revision 112530)
+++ gcc/c-typeck.c (working copy)
@@ -1446,7 +1446,7 @@
ptrtype = build_pointer_type (restype);
if (TREE_CODE (exp) == INDIRECT_REF)
- return convert (ptrtype, TREE_OPERAND (exp, 0));
+ return c_convert_internal (ptrtype, TREE_OPERAND (exp, 0));
if (TREE_CODE (exp) == VAR_DECL)
{
@@ -1464,7 +1464,7 @@
/* This way is better for a COMPONENT_REF since it can
simplify the offset for a component. */
adr = build_unary_op (ADDR_EXPR, exp, 1);
- return convert (ptrtype, adr);
+ return c_convert_internal (ptrtype, adr);
}
/* Convert the function expression EXP to a pointer. */
@@ -1540,7 +1540,33 @@
return exp;
}
+static bool
+c_promoting_integer_type_p2 (tree t)
+{
+ switch (TREE_CODE (t))
+ {
+ case INTEGER_TYPE:
+ return (TYPE_MAIN_VARIANT (t) == char_type_node
+ || TYPE_MAIN_VARIANT (t) == signed_char_type_node
+ || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
+ || TYPE_MAIN_VARIANT (t) == short_integer_type_node
+ || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
+ || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
+ case ENUMERAL_TYPE:
+ /* ??? Technically all enumerations not larger than an int
+ promote to an int. But this is used along code paths
+ that only want to notice a size change. */
+ return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
+
+ case BOOLEAN_TYPE:
+ return 1;
+
+ default:
+ return 0;
+ }
+}
+
/* EXP is an expression of integer type. Apply the integer promotions
to it and return the promoted value. */
@@ -1562,7 +1588,7 @@
>= TYPE_PRECISION (integer_type_node))
&& TYPE_UNSIGNED (type)));
- return convert (type, exp);
+ return c_convert_internal (type, exp);
}
/* ??? This should no longer be needed now bit-fields have their
@@ -1573,16 +1599,16 @@
c_promoting_integer_type_p, otherwise leave it alone. */
&& 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
TYPE_PRECISION (integer_type_node)))
- return convert (integer_type_node, exp);
+ return c_convert_internal (integer_type_node, exp);
- if (c_promoting_integer_type_p (type))
+ if (c_promoting_integer_type_p2 (type))
{
/* Preserve unsignedness if not really getting any wider. */
if (TYPE_UNSIGNED (type)
&& TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
- return convert (unsigned_type_node, exp);
+ return c_convert_internal (unsigned_type_node, exp);
- return convert (integer_type_node, exp);
+ return c_convert_internal (integer_type_node, exp);
}
return exp;
@@ -2483,7 +2509,7 @@
< TYPE_PRECISION (double_type_node))
&& !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val))))
/* Convert `float' to `double'. */
- result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
+ result = tree_cons (NULL_TREE, c_convert_internal (double_type_node, val), result);
else if ((invalid_func_diag =
targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
{
@@ -2705,8 +2731,8 @@
Do not do default conversions on the minus operator
in case restype is a short type. */
- op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
- convert (restype, op1), 0);
+ op0 = build_binary_op (MINUS_EXPR, c_convert_internal (restype, op0),
+ c_convert_internal (restype, op1), 0);
/* This generates an error if op1 is pointer to incomplete type. */
if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
error ("arithmetic on pointer to an incomplete type");
@@ -2715,7 +2741,7 @@
op1 = c_size_in_bytes (target_type);
/* Divide by the size, in easiest possible way. */
- return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
+ return fold_build2 (EXACT_DIV_EXPR, restype, op0, c_convert_internal (restype, op1));
}
/* Construct and perhaps optimize a tree representation
@@ -2848,7 +2874,7 @@
else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
else
- return convert (TREE_TYPE (arg), integer_zero_node);
+ return c_convert_internal (TREE_TYPE (arg), integer_zero_node);
case PREINCREMENT_EXPR:
case POSTINCREMENT_EXPR:
@@ -2920,7 +2946,7 @@
else
inc = integer_one_node;
- inc = convert (argtype, inc);
+ inc = c_convert_internal (argtype, inc);
/* Complain about anything else that is not a true lvalue. */
if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
@@ -2944,7 +2970,7 @@
else
val = build2 (code, TREE_TYPE (arg), arg, inc);
TREE_SIDE_EFFECTS (val) = 1;
- val = convert (result_type, val);
+ val = c_convert_internal (result_type, val);
if (TREE_CODE (val) != code)
TREE_NO_WARNING (val) = 1;
return val;
@@ -3560,7 +3586,7 @@
pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
ovalue = value;
- value = convert (type, value);
+ value = c_convert_internal (type, value);
/* Ignore any integer overflow caused by the cast. */
if (TREE_CODE (value) == INTEGER_CST)
@@ -3855,7 +3881,7 @@
/* Some types can interconvert without explicit casts. */
else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
&& vector_types_convertible_p (type, TREE_TYPE (rhs)))
- return convert (type, rhs);
+ return c_convert_internal (type, rhs);
/* Arithmetic types all interconvert, and enum is treated like int. */
else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
|| codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
@@ -4126,7 +4152,7 @@
"pointer type"),
G_("return from incompatible pointer type"));
- return convert (type, rhs);
+ return c_convert_internal (type, rhs);
}
else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
{
@@ -4150,7 +4176,7 @@
G_("return makes pointer from integer "
"without a cast"));
- return convert (type, rhs);
+ return c_convert_internal (type, rhs);
}
else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
{
@@ -4162,10 +4188,10 @@
"without a cast"),
G_("return makes integer from pointer "
"without a cast"));
- return convert (type, rhs);
+ return c_convert_internal (type, rhs);
}
else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
- return convert (type, rhs);
+ return c_convert_internal (type, rhs);
switch (errtype)
{
@@ -4637,7 +4663,7 @@
if (code == VECTOR_TYPE)
/* Although the types are compatible, we may require a
conversion. */
- inside_init = convert (type, inside_init);
+ inside_init = c_convert_internal (type, inside_init);
if (require_constant && !flag_isoc99
&& TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
@@ -5066,7 +5092,7 @@
constructor_max_index = build_int_cst (NULL_TREE, -1);
constructor_index
- = convert (bitsizetype,
+ = c_convert_internal (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
}
else
@@ -5082,7 +5108,7 @@
/* Vectors are like simple fixed-size arrays. */
constructor_max_index =
build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
- constructor_index = convert (bitsizetype, bitsize_zero_node);
+ constructor_index = c_convert_internal (bitsizetype, bitsize_zero_node);
constructor_unfilled_index = constructor_index;
}
else
@@ -5245,7 +5271,7 @@
/* Vectors are like simple fixed-size arrays. */
constructor_max_index =
build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
- constructor_index = convert (bitsizetype, integer_zero_node);
+ constructor_index = c_convert_internal (bitsizetype, integer_zero_node);
constructor_unfilled_index = constructor_index;
}
else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
@@ -5268,7 +5294,7 @@
constructor_max_index = build_int_cst (NULL_TREE, -1);
constructor_index
- = convert (bitsizetype,
+ = c_convert_internal (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
}
else
@@ -5571,7 +5597,7 @@
error_init ("array index in initializer exceeds array bounds");
else
{
- constructor_index = convert (bitsizetype, first);
+ constructor_index = c_convert_internal (bitsizetype, first);
if (last)
{
@@ -5584,7 +5610,7 @@
}
else
{
- last = convert (bitsizetype, last);
+ last = c_convert_internal (bitsizetype, last);
if (constructor_max_index != 0
&& tree_int_cst_lt (constructor_max_index, last))
{
@@ -5885,7 +5911,7 @@
{
if (TYPE_DOMAIN (constructor_type))
constructor_unfilled_index
- = convert (bitsizetype,
+ = c_convert_internal (bitsizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
else
constructor_unfilled_index = bitsize_zero_node;
@@ -6874,7 +6900,7 @@
{
if (pedantic)
pedwarn ("ISO C forbids %<goto *expr;%>");
- expr = convert (ptr_type_node, expr);
+ expr = c_convert_internal (ptr_type_node, expr);
return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
}
@@ -6918,7 +6944,7 @@
if (t == error_mark_node)
return NULL_TREE;
- inner = t = convert (TREE_TYPE (res), t);
+ inner = t = c_convert_internal (TREE_TYPE (res), t);
/* Strip any conversions, additions, and subtractions, and see if
we are returning the address of a local variable. Warn if so. */
@@ -7905,7 +7931,7 @@
/* Convert the shift-count to an integer, regardless of size
of value being shifted. */
if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
- op1 = convert (integer_type_node, op1);
+ op1 = c_convert_internal (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
}
@@ -7928,7 +7954,7 @@
/* Convert the shift-count to an integer, regardless of size
of value being shifted. */
if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
- op1 = convert (integer_type_node, op1);
+ op1 = c_convert_internal (integer_type_node, op1);
/* Avoid converting op1 to result_type later. */
converted = 1;
}
@@ -8121,8 +8147,8 @@
If we do not cast OP0 first, get_narrower would return
signed_char, which is inconsistent with the case of the
explicit cast. */
- op0 = convert (result_type, op0);
- op1 = convert (result_type, op1);
+ op0 = c_convert_internal (result_type, op0);
+ op1 = c_convert_internal (result_type, op1);
arg0 = get_narrower (op0, &unsigned0);
arg1 = get_narrower (op1, &unsigned1);
@@ -8212,7 +8238,7 @@
TREE_TYPE (arg0));
/* Convert value-to-be-shifted to that type. */
if (TREE_TYPE (op0) != result_type)
- op0 = convert (result_type, op0);
+ op0 = c_convert_internal (result_type, op0);
converted = 1;
}
}
@@ -8374,9 +8400,9 @@
if (!converted)
{
if (TREE_TYPE (op0) != result_type)
- op0 = convert (result_type, op0);
+ op0 = c_convert_internal (result_type, op0);
if (TREE_TYPE (op1) != result_type)
- op1 = convert (result_type, op1);
+ op1 = c_convert_internal (result_type, op1);
/* This can happen if one operand has a vector type, and the other
has a different type. */
@@ -8396,7 +8422,7 @@
op0, op1);
if (final_type != 0)
- result = convert (final_type, result);
+ result = c_convert_internal (final_type, result);
return result;
}
}
Index: gcc/gimplify.c
===================================================================
--- gcc/gimplify.c (revision 112530)
+++ gcc/gimplify.c (working copy)
@@ -2340,7 +2340,7 @@
default:
/* Other expressions that get here must have boolean values, but
might need to be converted to the appropriate mode. */
- return convert (boolean_type_node, expr);
+ return convert2 (boolean_type_node, expr);
}
}
@@ -3042,7 +3042,7 @@
i = VEC_index (constructor_elt, elts, 1)->value;
if (r == NULL || i == NULL)
{
- tree zero = convert (TREE_TYPE (type), integer_zero_node);
+ tree zero = convert2 (TREE_TYPE (type), integer_zero_node);
if (r == NULL)
r = zero;
if (i == NULL)
@@ -3545,8 +3545,8 @@
tree type = TREE_TYPE (*expr_p);
*expr_p = build3 (COND_EXPR, type, *expr_p,
- convert (type, boolean_true_node),
- convert (type, boolean_false_node));
+ convert2 (type, boolean_true_node),
+ convert2 (type, boolean_false_node));
return GS_OK;
}
Index: gcc/treelang/treelang.h
===================================================================
--- gcc/treelang/treelang.h (revision 112530)
+++ gcc/treelang/treelang.h (working copy)
@@ -155,3 +155,5 @@
void treelang_debug (void);
void sanity_check (struct prod_token_parm_item *item);
+
+tree treelang_convert (tree type, tree expr);
Index: gcc/treelang/tree-convert.c
===================================================================
--- gcc/treelang/tree-convert.c (revision 112530)
+++ gcc/treelang/tree-convert.c (working copy)
@@ -1,107 +0,0 @@
-/* Language-level data type conversion for Treelang.
- This is a very slightly modified copy of c-convert.c.
- Copyright (C) 1987, 1988, 1991, 1998, 2002, 2003 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
-
-
-/* This file contains the functions for converting C expressions
- to different data types. The only entry point is `convert'.
- Every language front end must have a `convert' function
- but what kind of conversions it does will depend on the language. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "diagnostic.h"
-#include "tree.h"
-#include "flags.h"
-#include "convert.h"
-#include "toplev.h"
-#include "langhooks.h"
-
-/* Change of width--truncation and extension of integers or reals--
- is represented with NOP_EXPR. Proper functioning of many things
- assumes that no other conversions can be NOP_EXPRs.
-
- Conversion between integer and pointer is represented with CONVERT_EXPR.
- Converting integer to real uses FLOAT_EXPR
- and real to integer uses FIX_TRUNC_EXPR.
-
- Here is a list of all the functions that assume that widening and
- narrowing is always done with a NOP_EXPR:
- In convert.c, convert_to_integer.
- In c-typeck.c, build_binary_op (boolean ops), and
- c_common_truthvalue_conversion.
- In expr.c: expand_expr, for operands of a MULT_EXPR.
- In fold-const.c: fold.
- In tree.c: get_narrower and get_unwidened. */
-
-/* Create an expression whose value is that of EXPR,
- converted to type TYPE. The TREE_TYPE of the value
- is always TYPE. This function implements all reasonable
- conversions; callers should filter out those that are
- not permitted by the language being compiled. */
-
-tree
-convert (tree type, tree expr)
-{
- tree e = expr;
- enum tree_code code = TREE_CODE (type);
-
- if (type == TREE_TYPE (expr)
- || TREE_CODE (expr) == ERROR_MARK
- || code == ERROR_MARK || TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
- return expr;
-
- if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
- return fold_build1 (NOP_EXPR, type, expr);
- if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
- return error_mark_node;
- if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
- {
- error ("void value not ignored as it ought to be");
- return error_mark_node;
- }
- if (code == VOID_TYPE)
- return build1 (CONVERT_EXPR, type, e);
- if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
- return fold (convert_to_integer (type, e));
- if (code == BOOLEAN_TYPE)
- {
- tree t = expr;
- /* If it returns a NOP_EXPR, we must fold it here to avoid
- infinite recursion between fold () and convert (). */
- if (TREE_CODE (t) == NOP_EXPR)
- return fold_build1 (NOP_EXPR, type, TREE_OPERAND (t, 0));
- else
- return fold_build1 (NOP_EXPR, type, t);
- }
- if (code == POINTER_TYPE || code == REFERENCE_TYPE)
- return fold (convert_to_pointer (type, e));
- if (code == REAL_TYPE)
- return fold (convert_to_real (type, e));
- if (code == COMPLEX_TYPE)
- return fold (convert_to_complex (type, e));
- if (code == VECTOR_TYPE)
- return fold (convert_to_vector (type, e));
-
- error ("conversion to non-scalar type requested");
- return error_mark_node;
-}
Index: gcc/treelang/Make-lang.in
===================================================================
--- gcc/treelang/Make-lang.in (revision 112530)
+++ gcc/treelang/Make-lang.in (working copy)
@@ -78,11 +78,11 @@
# no preprocessor
# core compiler
-tree1$(exeext): treelang/tree1.o treelang/treetree.o treelang/tree-convert.o \
+tree1$(exeext): treelang/tree1.o treelang/treetree.o \
treelang/lex.o treelang/parse.o \
$(BACKEND) $(LIBSDEPS) attribs.o
$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ \
- treelang/tree1.o treelang/treetree.o treelang/tree-convert.o \
+ treelang/tree1.o treelang/treetree.o \
treelang/lex.o treelang/parse.o \
$(BACKEND) $(LIBS) attribs.o
@@ -109,9 +109,6 @@
varray.h $(LANGHOOKS_DEF_H) langhooks.h treelang/treelang.h input.h \
treelang/treetree.h treelang/parse.h
-treelang/tree-convert.o: treelang/tree-convert.c $(CONFIG_H) $(SYSTEM_H) \
- coretypes.h diagnostic.h $(TREE_H) flags.h toplev.h langhooks.h $(TM_H)
-
treelang/spec.o: treelang/spec.c $(CONFIG_H) $(SYSTEM_H) \
coretypes.h diagnostic.h $(TREE_H) flags.h toplev.h langhooks.h $(TM_H)
Index: gcc/emit-rtl.c
===================================================================
--- gcc/emit-rtl.c (revision 112530)
+++ gcc/emit-rtl.c (working copy)
@@ -1596,7 +1596,7 @@
index, low_bound);
off_tree = size_binop (PLUS_EXPR,
- size_binop (MULT_EXPR, convert (sizetype,
+ size_binop (MULT_EXPR, convert2 (sizetype,
index),
unit_size),
off_tree);
Index: gcc/tree-mudflap.c
===================================================================
--- gcc/tree-mudflap.c (revision 112530)
+++ gcc/tree-mudflap.c (working copy)
@@ -550,7 +550,7 @@
/* Build: __mf_base = (uintptr_t) <base address expression>. */
t = build2 (MODIFY_EXPR, void_type_node, mf_base,
- convert (mf_uintptr_type, unshare_expr (base)));
+ convert2 (mf_uintptr_type, unshare_expr (base)));
SET_EXPR_LOCUS (t, locus);
gimplify_to_stmt_list (&t);
head = tsi_start (t);
@@ -558,7 +558,7 @@
/* Build: __mf_limit = (uintptr_t) <limit address expression>. */
t = build2 (MODIFY_EXPR, void_type_node, mf_limit,
- convert (mf_uintptr_type, unshare_expr (limit)));
+ convert2 (mf_uintptr_type, unshare_expr (limit)));
SET_EXPR_LOCUS (t, locus);
gimplify_to_stmt_list (&t);
tsi_link_after (&tsi, t, TSI_CONTINUE_LINKING);
@@ -826,7 +826,7 @@
limit = fold_build2 (MINUS_EXPR, mf_uintptr_type,
fold_build2 (PLUS_EXPR, mf_uintptr_type,
- convert (mf_uintptr_type, addr),
+ convert2 (mf_uintptr_type, addr),
size),
integer_one_node);
}
@@ -863,17 +863,17 @@
return;
bpu = bitsize_int (BITS_PER_UNIT);
- ofs = convert (bitsizetype, TREE_OPERAND (t, 2));
+ ofs = convert2 (bitsizetype, TREE_OPERAND (t, 2));
rem = size_binop (TRUNC_MOD_EXPR, ofs, bpu);
ofs = size_binop (TRUNC_DIV_EXPR, ofs, bpu);
- size = convert (bitsizetype, TREE_OPERAND (t, 1));
+ size = convert2 (bitsizetype, TREE_OPERAND (t, 1));
size = size_binop (PLUS_EXPR, size, rem);
size = size_binop (CEIL_DIV_EXPR, size, bpu);
- size = convert (sizetype, size);
+ size = convert2 (sizetype, size);
addr = TREE_OPERAND (TREE_OPERAND (t, 0), 0);
- addr = convert (ptr_type_node, addr);
+ addr = convert2 (ptr_type_node, addr);
addr = fold_build2 (PLUS_EXPR, ptr_type_node, addr, ofs);
base = addr;
@@ -994,12 +994,12 @@
tree unregister_fncall, unregister_fncall_params;
tree register_fncall, register_fncall_params;
- size = convert (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
+ size = convert2 (size_type_node, TYPE_SIZE_UNIT (TREE_TYPE (decl)));
/* (& VARIABLE, sizeof (VARIABLE), __MF_TYPE_STACK) */
unregister_fncall_params =
tree_cons (NULL_TREE,
- convert (ptr_type_node,
+ convert2 (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
@@ -1017,7 +1017,7 @@
variable_name = mf_varname_tree (decl);
register_fncall_params =
tree_cons (NULL_TREE,
- convert (ptr_type_node,
+ convert2 (ptr_type_node,
mf_mark (build1 (ADDR_EXPR,
build_pointer_type (TREE_TYPE (decl)),
decl))),
@@ -1174,11 +1174,11 @@
arg = build_int_cst (NULL_TREE, 4); /* __MF_TYPE_STATIC */
args = tree_cons (NULL_TREE, arg, args);
- arg = convert (size_type_node, object_size);
+ arg = convert2 (size_type_node, object_size);
args = tree_cons (NULL_TREE, arg, args);
arg = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (obj)), obj);
- arg = convert (ptr_type_node, arg);
+ arg = convert2 (ptr_type_node, arg);
args = tree_cons (NULL_TREE, arg, args);
call_stmt = build_function_call_expr (mf_register_fndecl, args);
Index: gcc/c-convert.c
===================================================================
--- gcc/c-convert.c (revision 112530)
+++ gcc/c-convert.c (working copy)
@@ -66,7 +66,7 @@
not permitted by the language being compiled. */
tree
-convert (tree type, tree expr)
+c_convert_internal (tree type, tree expr)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c (revision 112530)
+++ gcc/varasm.c (working copy)
@@ -4158,8 +4158,8 @@
return 0;
/* Compute the total number of array elements. */
- i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
- convert (sizetype,
+ i = size_binop (MINUS_EXPR, convert2 (sizetype, max_index),
+ convert2 (sizetype,
TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
Index: gcc/tree-object-size.c
===================================================================
--- gcc/tree-object-size.c (revision 112530)
+++ gcc/tree-object-size.c (working copy)
@@ -134,7 +134,7 @@
code = MINUS_EXPR;
t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
}
- t = convert (sizetype, t);
+ t = convert2 (sizetype, t);
off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
break;
Index: gcc/c-common.c
===================================================================
--- gcc/c-common.c (revision 112530)
+++ gcc/c-common.c (working copy)
@@ -1046,7 +1046,7 @@
if (TREE_CODE (c) == INTEGER_CST)
return int_fits_type_p (c, type);
- c = convert (type, c);
+ c = convert2 (type, c);
return !TREE_OVERFLOW (c);
}
@@ -1071,7 +1071,7 @@
tree
convert_and_check (tree type, tree expr)
{
- tree t = convert (type, expr);
+ tree t = convert2 (type, expr);
if (TREE_CODE (t) == INTEGER_CST)
{
if (TREE_OVERFLOW (t))
@@ -1586,9 +1586,9 @@
}
if (*case_low_p != case_low)
- *case_low_p = convert (type, case_low);
+ *case_low_p = convert2 (type, case_low);
if (case_high_p && *case_high_p != case_high)
- *case_high_p = convert (type, case_high);
+ *case_high_p = convert2 (type, case_high);
return true;
}
@@ -2108,8 +2108,8 @@
}
if (type != *restype_ptr)
{
- minval = convert (*restype_ptr, minval);
- maxval = convert (*restype_ptr, maxval);
+ minval = convert2 (*restype_ptr, minval);
+ maxval = convert2 (*restype_ptr, maxval);
}
if (unsignedp && unsignedp0)
@@ -2254,11 +2254,11 @@
/* Make sure shorter operand is extended the right way
to match the longer operand. */
primop0
- = convert (c_common_signed_or_unsigned_type (unsignedp0,
+ = convert2 (c_common_signed_or_unsigned_type (unsignedp0,
TREE_TYPE (primop0)),
primop0);
primop1
- = convert (c_common_signed_or_unsigned_type (unsignedp1,
+ = convert2 (c_common_signed_or_unsigned_type (unsignedp1,
TREE_TYPE (primop1)),
primop1);
}
@@ -2283,7 +2283,7 @@
so suppress the warning. */
if (extra_warnings && !in_system_header
&& !(TREE_CODE (primop0) == INTEGER_CST
- && !TREE_OVERFLOW (convert (c_common_signed_type (type),
+ && !TREE_OVERFLOW (convert2 (c_common_signed_type (type),
primop0))))
warning (0, "comparison of unsigned expression >= 0 is always true");
value = truthvalue_true_node;
@@ -2292,7 +2292,7 @@
case LT_EXPR:
if (extra_warnings && !in_system_header
&& !(TREE_CODE (primop0) == INTEGER_CST
- && !TREE_OVERFLOW (convert (c_common_signed_type (type),
+ && !TREE_OVERFLOW (convert2 (c_common_signed_type (type),
primop0))))
warning (0, "comparison of unsigned expression < 0 is always false");
value = truthvalue_false_node;
@@ -2313,8 +2313,8 @@
}
}
- *op0_ptr = convert (type, primop0);
- *op1_ptr = convert (type, primop1);
+ *op0_ptr = convert2 (type, primop0);
+ *op1_ptr = convert2 (type, primop1);
*restype_ptr = truthvalue_type_node;
@@ -2381,8 +2381,8 @@
because weird cases involving pointer arithmetic
can result in a sum or difference with different type args. */
ptrop = build_binary_op (subcode, ptrop,
- convert (int_type, TREE_OPERAND (intop, 1)), 1);
- intop = convert (int_type, TREE_OPERAND (intop, 0));
+ convert2 (int_type, TREE_OPERAND (intop, 1)), 1);
+ intop = convert2 (int_type, TREE_OPERAND (intop, 0));
}
/* Convert the integer argument to a type the same size as sizetype
@@ -2390,16 +2390,16 @@
if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
|| TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
- intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
+ intop = convert2 (c_common_type_for_size (TYPE_PRECISION (sizetype),
TYPE_UNSIGNED (sizetype)), intop);
/* Replace the integer argument with a suitable product by the object size.
Do this multiplication as signed, then convert to the appropriate
pointer type (actually unsigned integral). */
- intop = convert (result_type,
+ intop = convert2 (result_type,
build_binary_op (MULT_EXPR, intop,
- convert (TREE_TYPE (intop), size_exp), 1));
+ convert2 (TREE_TYPE (intop), size_exp), 1));
/* Create the sum or difference. */
return fold_build2 (resultcode, result_type, ptrop, intop);
@@ -5979,7 +5979,7 @@
code = MINUS_EXPR;
t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
}
- t = convert (sizetype, t);
+ t = convert2 (sizetype, t);
off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
break;
@@ -5994,7 +5994,7 @@
fold_offsetof (tree expr)
{
/* Convert back from the internal sizetype to size_t. */
- return convert (size_type_node, fold_offsetof_1 (expr));
+ return convert2 (size_type_node, fold_offsetof_1 (expr));
}
/* Print an error message for an invalid lvalue. USE says
@@ -6203,8 +6203,8 @@
so that we get warnings for anything that doesn't match the pointer
type. This isn't portable across the C and C++ front ends atm. */
val = TREE_VALUE (params);
- val = convert (ptype, val);
- val = convert (TREE_VALUE (arg_types), val);
+ val = convert2 (ptype, val);
+ val = convert2 (TREE_VALUE (arg_types), val);
TREE_VALUE (params) = val;
arg_types = TREE_CHAIN (arg_types);
@@ -6229,7 +6229,7 @@
{
tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
ptype = TYPE_MAIN_VARIANT (ptype);
- return convert (ptype, result);
+ return convert2 (ptype, result);
}
/* Some builtin functions are placeholders for other expressions. This
Index: gcc/convert.c
===================================================================
--- gcc/convert.c (revision 112530)
+++ gcc/convert.c (working copy)
@@ -324,7 +324,7 @@
return build1 (FLOAT_EXPR, type, expr);
case COMPLEX_TYPE:
- return convert (type,
+ return convert2 (type,
fold_build1 (REALPART_EXPR,
TREE_TYPE (TREE_TYPE (expr)), expr));
@@ -498,7 +498,7 @@
else if (TREE_CODE (type) == ENUMERAL_TYPE
|| outprec != GET_MODE_BITSIZE (TYPE_MODE (type)))
return build1 (NOP_EXPR, type,
- convert (lang_hooks.types.type_for_mode
+ convert2 (lang_hooks.types.type_for_mode
(TYPE_MODE (type), TYPE_UNSIGNED (type)),
expr));
@@ -648,10 +648,10 @@
typex = lang_hooks.types.unsigned_type (typex);
else
typex = lang_hooks.types.signed_type (typex);
- return convert (type,
+ return convert2 (type,
fold_build2 (ex_form, typex,
- convert (typex, arg0),
- convert (typex, arg1)));
+ convert2 (typex, arg0),
+ convert2 (typex, arg1)));
}
}
}
@@ -670,9 +670,9 @@
typex = lang_hooks.types.unsigned_type (type);
else
typex = lang_hooks.types.signed_type (type);
- return convert (type,
+ return convert2 (type,
fold_build1 (ex_form, typex,
- convert (typex,
+ convert2 (typex,
TREE_OPERAND (expr, 0))));
}
@@ -685,14 +685,14 @@
break;
/* If truncating after truncating, might as well do all at once.
If truncating after extending, we may get rid of wasted work. */
- return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
+ return convert2 (type, get_unwidened (TREE_OPERAND (expr, 0), type));
case COND_EXPR:
/* It is sometimes worthwhile to push the narrowing down through
the conditional and never loses. */
return fold_build3 (COND_EXPR, type, TREE_OPERAND (expr, 0),
- convert (type, TREE_OPERAND (expr, 1)),
- convert (type, TREE_OPERAND (expr, 2)));
+ convert2 (type, TREE_OPERAND (expr, 1)),
+ convert2 (type, TREE_OPERAND (expr, 2)));
default:
break;
@@ -704,7 +704,7 @@
return build1 (FIX_TRUNC_EXPR, type, expr);
case COMPLEX_TYPE:
- return convert (type,
+ return convert2 (type,
fold_build1 (REALPART_EXPR,
TREE_TYPE (TREE_TYPE (expr)), expr));
@@ -718,7 +718,7 @@
default:
error ("aggregate value used where an integer was expected");
- return convert (type, integer_zero_node);
+ return convert2 (type, integer_zero_node);
}
}
@@ -735,8 +735,8 @@
case INTEGER_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
- return build2 (COMPLEX_EXPR, type, convert (subtype, expr),
- convert (subtype, integer_zero_node));
+ return build2 (COMPLEX_EXPR, type, convert2 (subtype, expr),
+ convert2 (subtype, integer_zero_node));
case COMPLEX_TYPE:
{
@@ -746,18 +746,18 @@
return expr;
else if (TREE_CODE (expr) == COMPLEX_EXPR)
return fold_build2 (COMPLEX_EXPR, type,
- convert (subtype, TREE_OPERAND (expr, 0)),
- convert (subtype, TREE_OPERAND (expr, 1)));
+ convert2 (subtype, TREE_OPERAND (expr, 0)),
+ convert2 (subtype, TREE_OPERAND (expr, 1)));
else
{
expr = save_expr (expr);
return
fold_build2 (COMPLEX_EXPR, type,
- convert (subtype,
+ convert2 (subtype,
fold_build1 (REALPART_EXPR,
TREE_TYPE (TREE_TYPE (expr)),
expr)),
- convert (subtype,
+ convert2 (subtype,
fold_build1 (IMAGPART_EXPR,
TREE_TYPE (TREE_TYPE (expr)),
expr)));