* tree.h (TYPE_CACHED_VALUES_P): New.
(TYPE_CACHED_VALUES): New.
(TYPE_ORIG_SIZE_TYPE): Adjust.
* tree.def (INTEGER_CST): Update documentation.
* tree.c: Inlcude params.h.
(build_int_cst): Cache small values.
(build_type_copy): Do not copy the value cache.
* c-common.c (c_common_nodes_and_builtins): Add comment, remove
unneeded zeroing.
* c-typeck.c (build_c_cast): Add comment about OVERFLOW setting.
* expmed.c (const_mult_add_overflow_p): Clear type copy's value
cache.
* fold-const.c (force_fit_type): Copy value when setting
overflows.
(int_const_binop): Likewise.
* stor-layout.c: Include params.h
(set_sizetype): Create values cache.
(fixup_unsigned_type): Set UNSIGNED_P before caching any values.
* params.def (PARAM_INTEGER_SHARE_LIMIT): New.
* params.h (INTEGER_SHARE_LIMIT): New.
* Makefile.in (tree.o, stor-layout.o): Depend on PARAMS_H.
* cp/decl.c (finish_enum): Do not copy value node early, copy
later.
* cp/lex.c (cxx_init): Force null_node to be unique.
* java/parse.h (JAVA_RADIX10_FLAG): Rename to ...
(JAVA_NOT_RADIX10_FLAG): ... here. Invert meaning.
* java/lex.c (do_java_lex): Adjust.
(error_if_numeric_overflow): Likewise.
From-SVN: r86247
+2004-08-19 Nathan Sidwell <nathan@codesourcery.com>
+
+ * tree.h (TYPE_CACHED_VALUES_P): New.
+ (TYPE_CACHED_VALUES): New.
+ (TYPE_ORIG_SIZE_TYPE): Adjust.
+ * tree.def (INTEGER_CST): Update documentation.
+ * tree.c: Inlcude params.h.
+ (build_int_cst): Cache small values.
+ (build_type_copy): Do not copy the value cache.
+ * c-common.c (c_common_nodes_and_builtins): Add comment, remove
+ unneeded zeroing.
+ * c-typeck.c (build_c_cast): Add comment about OVERFLOW setting.
+ * expmed.c (const_mult_add_overflow_p): Clear type copy's value
+ cache.
+ * fold-const.c (force_fit_type): Copy value when setting
+ overflows.
+ (int_const_binop): Likewise.
+ * stor-layout.c: Include params.h
+ (set_sizetype): Create values cache.
+ (fixup_unsigned_type): Set UNSIGNED_P before caching any values.
+ * params.def (PARAM_INTEGER_SHARE_LIMIT): New.
+ * params.h (INTEGER_SHARE_LIMIT): New.
+ * Makefile.in (tree.o, stor-layout.o): Depend on PARAMS_H.
+
2004-08-19 Paolo Bonzini <bonzini@gnu.org>
* gimplify.c (gimplify_minimax_expr): Remove.
* reg-stack.c (emit_swap_insn): Add condition to step over
NOTE_INSN_UNLIKELY_EXECUTED_CODE notes.
* toplev.c (user_defined_section_attribute): New global variable.
- * toplev.h (user_defined_section_attribute): Extern declaration for new
- global variable.
+ * toplev.h (user_defined_section_attribute): Extern declaration
+ for new global variable.
* varasm.c (unlikely_section_label): New global variable.
(unlikely_text_section_name): New global variable.
- (unlikely_text_section): Add code to initialize unlikely_text_section_name
- if necessary; modify to use unlikely_text_section_name and
- unlikely_section_label; also to use named_section properly.
- (in_unlikely_text_section): Modify to work correctly with named_section
- and to use unlikely_text_section_name.
+ (unlikely_text_section): Add code to initialize
+ unlikely_text_section_name if necessary; modify to use
+ unlikely_text_section_name and unlikely_section_label; also to use
+ named_section properly.
+ (in_unlikely_text_section): Modify to work correctly with
+ named_section and to use unlikely_text_section_name.
(named_section): Add code to work properly with cold section.
(function_section): Clean up if-statement.
- * config/darwin.c (darwin_asm_named_section): Return to original code,
- removing use of SECTION_FORMAT_STRING.
+ * config/darwin.c (darwin_asm_named_section): Return to original
+ code, removing use of SECTION_FORMAT_STRING.
* config/arm/pe.h (switch_to_section): Add case for
in_unlikely_executed_text to switch statement.
* config/i386/cygming.h (switch_to_section): Likewise.
2004-08-17 Dorit Naishlos <dorit@il.ibm.com>
- * tree-vectorizer.c: New File: loop vectorization on SSAed GIMPLE trees.
+ * tree-vectorizer.c: New File: loop vectorization on SSAed GIMPLE
+ trees.
* tree-vectorizer.h: New File: Same.
* Makefile.in (tree-vectorizer.c, tree-vectorizer.h): Add new files.
* common.opt (ftree-vectorize): New flag to enable vectorization.
- * timevar.def (TV_TREE_VECTORIZATION): New dump file for vectorization
- pass.
+ * timevar.def (TV_TREE_VECTORIZATION): New dump file for
+ vectorization pass.
* tree-data-ref.h (init_data_ref): Additional argument.
(array_base_name_differ_p): Moved to tree-data-ref.c.
* tree-data-ref.c (array_base_name_differ_p): Revised.
with an extra argument.
(analyze_all_data_dependences): Same.
(init_data_ref): Additional argument is_read to set DR_IS_READ.
- * tree-ssa-phiopt.c (empty_block_p): Expose for usage out of this file.
+ * tree-ssa-phiopt.c (empty_block_p): Expose for usage out of this
+ file.
* tree-flow.h (vectorize_loops, empty_block_p): Add declaration.
* tree-optimize.c (pass_vectorize): Schedule the vectorization pass.
* tree-pass.h (tree_opt_pass pass_vectorize): Declare the new
* tree-ssa-loop.c (tree_ssa_loop_init): Call scev_initialize.
(tree_ssa_loop_done): Call scev_finalize.
(tree_vectorize): Define the new vectorization pass.
- * defaults.h (UNITS_PER_SIMD_WORD): Allow targets to specify the size of
- the vector they support (until support for multiple vector sizes is
- added to the vectorizer).
+ * defaults.h (UNITS_PER_SIMD_WORD): Allow targets to specify the
+ size of the vector they support (until support for multiple vector
+ sizes is added to the vectorizer).
* config/i386/i386.h (UNITS_PER_SIMD_WORD): Define.
* config/rs6000/rs6000.h (UNITS_PER_SIMD_WORD): Define.
* invoke.texi (fdump-tree-vect, ftree-vectorize): Add
* config/i386/xmmintrin.h: Include <mm_malloc.h>.
2004-08-03 H.J. Lu <hongjiu.lu@intel.com>
- Tanguy Fautrà <tfautre@pandora.be>
+ Tanguy FautrÃ\83 <tfautre@pandora.be>
* config/i386/pmm_malloc.h: New file.
langhooks.o : langhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) toplev.h \
tree-inline.h $(RTL_H) insn-config.h $(INTEGRATE_H) langhooks.h \
$(LANGHOOKS_DEF_H) $(FLAGS_H) $(GGC_H) diagnostic.h
-tree.o : tree.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(FLAGS_H) function.h \
+tree.o : tree.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
+ $(FLAGS_H) function.h $(PARAMS_H) \
toplev.h $(GGC_H) $(HASHTAB_H) $(TARGET_H) output.h $(TM_P_H) langhooks.h \
real.h gt-tree.h tree-iterator.h $(BASIC_BLOCK_H) $(TREE_FLOW_H)
tree-dump.o: tree-dump.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
$(TREE_GIMPLE_H)
print-tree.o : print-tree.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
$(GGC_H) langhooks.h real.h
-stor-layout.o : stor-layout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
- $(FLAGS_H) function.h $(EXPR_H) $(RTL_H) toplev.h $(GGC_H) $(TM_P_H) $(TARGET_H) \
+stor-layout.o : stor-layout.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
+ $(TREE_H) $(PARAMS_H) $(FLAGS_H) function.h $(EXPR_H) $(RTL_H) toplev.h \
+ $(GGC_H) $(TM_P_H) $(TARGET_H) \
langhooks.h $(REGS_H)
tree-alias-type.o: tree-alias-type.c tree-alias-type.h $(SYSTEM_H) $(CONFIG_H) \
$(GGC_H) $(TM_H) coretypes.h $(VARRAY_H)
record_builtin_type (RID_VOID, NULL, void_type_node);
+ /* This node must not be shared. */
void_zero_node = make_node (INTEGER_CST);
- TREE_INT_CST_LOW (void_zero_node) = 0;
- TREE_INT_CST_HIGH (void_zero_node) = 0;
TREE_TYPE (void_zero_node) = void_type_node;
void_list_node = build_void_list_node ();
if (TREE_CODE (value) == INTEGER_CST)
{
if (EXPR_P (ovalue))
+ /* If OVALUE had overflow set, then so will VALUE, so it
+ is safe to overwrite. */
TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
else
TREE_OVERFLOW (value) = 0;
if (TREE_CODE_CLASS (TREE_CODE (ovalue)) == 'c')
+ /* Similarly, constant_overflow cannot have become
+ cleared. */
TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
}
}
+2004-08-19 Nathan Sidwell <nathan@codesourcery.com>
+
+ * decl.c (finish_enum): Do not copy value node early, copy
+ later.
+ * lex.c (cxx_init): Force null_node to be unique.
+
2004-08-19 Joseph S. Myers <jsm@polyomino.org.uk>
PR c++/17041
maxnode = value;
else if (tree_int_cst_lt (value, minnode))
minnode = value;
-
- /* Set the TREE_TYPE for the values as well. That's so that when
- we call decl_constant_value we get an entity of the right type
- (but with the constant value). But first make a copy so we
- don't clobber shared INTEGER_CSTs. */
- if (TREE_TYPE (value) != enumtype)
- {
- value = DECL_INITIAL (decl) = copy_node (value);
- TREE_TYPE (value) = enumtype;
- }
}
}
else
decl = TREE_VALUE (values);
value = perform_implicit_conversion (underlying_type,
DECL_INITIAL (decl));
+
+ /* Do not clobber shared ints. */
+ value = copy_node (value);
+
TREE_TYPE (value) = enumtype;
DECL_INITIAL (decl) = value;
TREE_VALUE (values) = value;
cxx_init_decl_processing ();
- /* Create the built-in __null node. */
- null_node = build_int_cst (c_common_type_for_size (POINTER_SIZE, 0), 0, 0);
+ /* Create the built-in __null node. It is important that this is
+ not shared. */
+ null_node = make_node (INTEGER_CST);
+ TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
ridpointers[RID_NULL] = null_node;
interface_unknown = 1;
UNSIGNEDP is nonzero to do unsigned multiplication. */
bool
-const_mult_add_overflow_p (rtx x, rtx mult, rtx add, enum machine_mode mode, int unsignedp)
+const_mult_add_overflow_p (rtx x, rtx mult, rtx add,
+ enum machine_mode mode, int unsignedp)
{
tree type, mult_type, add_type, result;
mult_type = type;
if (unsignedp)
{
+ /* FIXME:It would be nice if we could step directly from this
+ type to its sizetype equivalent. */
mult_type = copy_node (type);
+ if (TYPE_CACHED_VALUES_P (mult_type))
+ {
+ /* Clear any set of cached values it has. */
+ TYPE_CACHED_VALUES_P (mult_type) = 0;
+ TYPE_CACHED_VALUES (mult_type) = NULL_TREE;
+ }
TYPE_IS_SIZETYPE (mult_type) = 1;
}
if (overflowed || overflowed_const
|| low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
{
+ t = build_int_cst (TREE_TYPE (t), low, high);
+
if (overflowed
|| overflowable < 0
|| (overflowable > 0 && sign_extended_type))
{
+ t = copy_node (t);
TREE_OVERFLOW (t) = 1;
TREE_CONSTANT_OVERFLOW (t) = 1;
}
else if (overflowed_const)
- TREE_CONSTANT_OVERFLOW (t) = 1;
-
- TREE_INT_CST_LOW (t) = low;
- TREE_INT_CST_HIGH (t) = high;
+ {
+ t = copy_node (t);
+ TREE_CONSTANT_OVERFLOW (t) = 1;
+ }
}
return t;
/* Propagate overflow flags ourselves. */
if (((!uns || is_sizetype) && overflow)
| TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
- TREE_OVERFLOW (t) = 1;
-
- if (TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1)
- | TREE_CONSTANT_OVERFLOW (arg2))
- TREE_CONSTANT_OVERFLOW (t) = 1;
+ {
+ t = copy_node (t);
+ TREE_OVERFLOW (t) = 1;
+ TREE_CONSTANT_OVERFLOW (t) = 1;
+ }
+ else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
+ {
+ t = copy_node (t);
+ TREE_CONSTANT_OVERFLOW (t) = 1;
+ }
}
else
t = force_fit_type (t, 1,
+2004-08-19 Nathan Sidwell <nathan@codesourcery.com>
+
+ * parse.h (JAVA_RADIX10_FLAG): Rename to ...
+ (JAVA_NOT_RADIX10_FLAG): ... here. Invert meaning.
+ * lex.c (do_java_lex): Adjust.
+ (error_if_numeric_overflow): Likewise.
+
2004-08-18 Andrew Pinski <apinski@apple.com>
- * class.c (make_local_function_alias): Only make a new decl if we support
- alias attribute on all decls.
+ * class.c (make_local_function_alias): Only make a new decl if we
+ support alias attribute on all decls.
2004-08-18 Bryce McKinlay <mckinlay@redhat.com>
value = build_int_cst (long_suffix ? long_type_node : int_type_node,
low, high);
value = force_fit_type (value, 0, false, false);
- SET_LVAL_NODE (value);
+
+ if (radix != 10)
+ {
+ value = copy_node (value);
+ JAVA_NOT_RADIX10_FLAG (value) = 1;
+ }
- JAVA_RADIX10_FLAG (value) = radix == 10;
+ SET_LVAL_NODE (value);
#endif
return INT_LIT_TK;
}
error_if_numeric_overflow (tree value)
{
if (TREE_CODE (value) == INTEGER_CST
- && JAVA_RADIX10_FLAG (value)
+ && !JAVA_NOT_RADIX10_FLAG (value)
&& tree_int_cst_sgn (value) < 0)
{
if (TREE_TYPE (value) == long_type_node)
TREE_PURPOSE (CPC_INSTANCE_INITIALIZER_LIST (C)) = (S);
/* This is used by the lexer to communicate with the parser. It is
- set on an integer constant if the radix is 10, so that the parser
+ set on an integer constant if the radix is NOT 10, so that the parser
can correctly diagnose a numeric overflow. */
-#define JAVA_RADIX10_FLAG(NODE) TREE_LANG_FLAG_0(NODE)
+#define JAVA_NOT_RADIX10_FLAG(NODE) TREE_LANG_FLAG_0(NODE)
#ifndef JC1_LITE
void java_complete_class (void);
"The maximum number of insns in a region to be considered for interblock scheduling",
100)
+/* INTEGER_CST nodes are shared for values [{-1,0} .. N) for
+ {signed,unsigned} integral types. This determines N.
+ Experimentation shows 256 to be a good value. */
+DEFPARAM (PARAM_INTEGER_SHARE_LIMIT,
+ "integer-share-limit",
+ "The upper bound for sharing integer constants",
+ 256)
+
/*
Local variables:
mode:c
PARAM_VALUE (PARAM_GLOBAL_VAR_THRESHOLD)
#define MAX_ALIASED_VOPS \
PARAM_VALUE (PARAM_MAX_ALIASED_VOPS)
+#define INTEGER_SHARE_LIMIT \
+ PARAM_VALUE (PARAM_INTEGER_SHARE_LIMIT)
#endif /* ! GCC_PARAMS_H */
#include "target.h"
#include "langhooks.h"
#include "regs.h"
+#include "params.h"
/* Set to one when set_sizetype has been called. */
static int sizetype_set;
/* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */
sizetype = copy_node (type);
- TYPE_ORIG_SIZE_TYPE (sizetype) = type;
+ TYPE_CACHED_VALUES (sizetype) = make_tree_vec (INTEGER_SHARE_LIMIT);
+ TYPE_CACHED_VALUES_P (sizetype) = 1;
+ TREE_TYPE (TYPE_CACHED_VALUES (sizetype)) = type;
TYPE_IS_SIZETYPE (sizetype) = 1;
bitsizetype = make_node (INTEGER_TYPE);
TYPE_NAME (bitsizetype) = TYPE_NAME (type);
if (precision > HOST_BITS_PER_WIDE_INT * 2)
precision = HOST_BITS_PER_WIDE_INT * 2;
+ TYPE_UNSIGNED (type) = 1;
+
set_min_and_max_values_for_integral_type (type, precision,
/*is_unsigned=*/true);
#include "tree-iterator.h"
#include "basic-block.h"
#include "tree-flow.h"
+#include "params.h"
/* obstack.[ch] explicitly declined to prototype this. */
extern int _obstack_allocated_p (struct obstack *h, void *obj);
build_int_cst (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
{
tree t;
+ int ix = -1;
+ int limit = 0;
if (!type)
type = integer_type_node;
-
+
+ switch (TREE_CODE (type))
+ {
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ /* Cache NULL pointer. */
+ if (!hi && !low)
+ {
+ limit = 1;
+ ix = 0;
+ }
+ break;
+
+ case BOOLEAN_TYPE:
+ /* Cache false or true. */
+ limit = 2;
+ if (!hi && low < 2)
+ ix = low;
+ break;
+
+ case INTEGER_TYPE:
+ case CHAR_TYPE:
+ case OFFSET_TYPE:
+ if (TYPE_UNSIGNED (type))
+ {
+ /* Cache 0..N */
+ limit = INTEGER_SHARE_LIMIT;
+ if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
+ ix = low;
+ }
+ else
+ {
+ /* Cache -1..N */
+ limit = INTEGER_SHARE_LIMIT + 1;
+ if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
+ ix = low + 1;
+ else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
+ ix = 0;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (ix >= 0)
+ {
+ if (!TYPE_CACHED_VALUES_P (type))
+ {
+ TYPE_CACHED_VALUES_P (type) = 1;
+ TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
+ }
+
+ t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
+ if (t)
+ {
+ /* Make sure no one is clobbering the shared constant. */
+ if (TREE_TYPE (t) != type)
+ abort ();
+ if (TREE_INT_CST_LOW (t) != low || TREE_INT_CST_HIGH (t) != hi)
+ abort ();
+ return t;
+ }
+ }
+
t = make_node (INTEGER_CST);
TREE_INT_CST_LOW (t) = low;
TREE_INT_CST_HIGH (t) = hi;
TREE_TYPE (t) = type;
+
+ if (ix >= 0)
+ TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
+
return t;
}
tree t, m = TYPE_MAIN_VARIANT (type);
t = copy_node (type);
+ if (TYPE_CACHED_VALUES_P(t))
+ {
+ /* Do not copy the values cache. */
+ if (TREE_CODE (t) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t))
+ abort ();
+ TYPE_CACHED_VALUES_P (t) = 0;
+ TYPE_CACHED_VALUES (t) = NULL_TREE;
+ }
TYPE_POINTER_TO (t) = 0;
TYPE_REFERENCE_TO (t) = 0;
/* First, the constants. */
/* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields,
- 32 bits each, giving us a 64 bit constant capability.
- Note: constants of type char in Pascal are INTEGER_CST,
- and so are pointer constants such as nil in Pascal or NULL in C.
- `(int *) 1' in C also results in an INTEGER_CST. */
+ 32 bits each, giving us a 64 bit constant capability. INTEGER_CST
+ nodes can be shared, and therefore should be considered read only.
+ They should be copied, before setting a flag such as
+ TREE_OVERFLOW. If an INTEGER_CST has TREE_OVERFLOW or
+ TREE_CONSTANT_OVERFLOW already set, it is known to be unique.
+ INTEGER_CST nodes are created for the integral types, for pointer
+ types and for vector and float types in some circumstances. */
DEFTREECODE (INTEGER_CST, "integer_cst", 'c', 0)
/* Contents are in TREE_REAL_CST field. */
VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
ASM_VOLATILE_P in
ASM_EXPR
+ TYPE_CACHED_VALUES_P in
+ ..._TYPE
private_flag:
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
+/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
+ of cached values, or is something else. */
+#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->common.public_flag)
+
/* In any expression, decl, or constant, nonzero means it has side effects or
reevaluation of the whole expression could produce a different value.
This is set if any subexpression is a function call, a side effect or a
#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
-#define TYPE_ORIG_SIZE_TYPE(NODE) (INTEGER_TYPE_CHECK (NODE)->type.values)
#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
#define TYPE_DOMAIN(NODE) (SET_OR_ARRAY_CHECK (NODE)->type.values)
#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
+#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
+#define TYPE_ORIG_SIZE_TYPE(NODE) \
+ (INTEGER_TYPE_CHECK (NODE)->type.values \
+ ? TREE_TYPE ((NODE)->type.values) : NULL_TREE)
#define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval)
#define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval)
#define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
projects / gcc.git / commitdiff