summaryrefslogtreecommitdiffstats
path: root/gcc
diff options
context:
space:
mode:
Diffstat (limited to 'gcc')
-rw-r--r--gcc/ChangeLog18
-rw-r--r--gcc/ada/ChangeLog6
-rw-r--r--gcc/ada/decl.c4
-rw-r--r--gcc/ada/utils.c2
-rw-r--r--gcc/ada/utils2.c4
-rw-r--r--gcc/c-decl.c2
-rw-r--r--gcc/c-typeck.c4
-rw-r--r--gcc/calls.c5
-rw-r--r--gcc/cp/ChangeLog7
-rw-r--r--gcc/cp/init.c1
-rw-r--r--gcc/cp/tree.c4
-rw-r--r--gcc/emit-rtl.c2
-rw-r--r--gcc/objc/objc-act.c6
-rw-r--r--gcc/print-tree.c7
-rw-r--r--gcc/tree.c10
-rw-r--r--gcc/tree.h59
16 files changed, 97 insertions, 44 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index a2f3179776e..4c20840d28a 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,21 @@
+2004-04-05 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * c-decl.c (build_compound_literal): Use TYPE_READONLY.
+ * emit-rtl.c (set_mem_attributes_minus_bitpos): Likewise.
+ * objc/objc-act.c (adorn_decl, gen_declspecs): Likewise.
+ * c-typeck.c (decl_constant_value): Don't access DECL_INITIAL of a
+ PARM_DECL.
+ * calls.c (flags_from_decl_or_type): Use TYPE_READONLY and do so only
+ for a type.
+ * print-tree.c (print_node): Properly handle side-effects, readonly,
+ and constant flags.
+ * tree.c (build1_stat, build_expr_wfl): Only look at TREE_SIDE_EFFECTS
+ and TREE_CONSTANT if not a type.
+ * tree.h (IS_NON_TYPE_CODE_CLASS): New macro.
+ (IS_EXPR_CODE_CLASS): Write 'E', not 'e'.
+ (NON_TYPE_CHECK): New macro.
+ (TREE_SIDE_EFFECT, TREE_READONLY, TREE_CONSTANT: Add check.
+
2004-04-05 Eric Botcazou <ebotcazou@libertysurf.fr>
* config/sparc/sol2-bi.h (PREFERRED_DEBUGGING_TYPE): Set
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog
index aa8217d15b0..1ff5439c701 100644
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,9 @@
+2004-04-05 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * decl.c (gnat_to_gnu_entity): Use TYPE_READONLY.
+ * utils.c (create_field_decl): Likewise.
+ * utils2.c (build_unary_op, gnat_build_constructor): Likewise.
+
2004-04-02 Arnaud Charlet <charlet@act-europe.fr>
* gnat-style.texi, gnat_rm.texi, gnat_ugn.texi: Remove RCS tags.
diff --git a/gcc/ada/decl.c b/gcc/ada/decl.c
index c7b66c7f15e..5b0581fd819 100644
--- a/gcc/ada/decl.c
+++ b/gcc/ada/decl.c
@@ -1443,7 +1443,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
= create_concat_name (gnat_entity, "XUB");
TYPE_NAME (gnu_fat_type) = create_concat_name (gnat_entity, "XUP");
TYPE_IS_FAT_POINTER_P (gnu_fat_type) = 1;
- TREE_READONLY (gnu_template_type) = 1;
+ TYPE_READONLY (gnu_template_type) = 1;
/* Make a node for the array. If we are not defining the array
suppress expanding incomplete types and save the node as the type
@@ -1553,7 +1553,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
/* Install all the fields into the template. */
finish_record_type (gnu_template_type, gnu_template_fields, 0, 0);
- TREE_READONLY (gnu_template_type) = 1;
+ TYPE_READONLY (gnu_template_type) = 1;
/* Now make the array of arrays and update the pointer to the array
in the fat pointer. Note that it is the first field. */
diff --git a/gcc/ada/utils.c b/gcc/ada/utils.c
index 0fe1892b272..1cefff8266c 100644
--- a/gcc/ada/utils.c
+++ b/gcc/ada/utils.c
@@ -1403,7 +1403,7 @@ create_field_decl (tree field_name,
tree field_decl = build_decl (FIELD_DECL, field_name, field_type);
DECL_CONTEXT (field_decl) = record_type;
- TREE_READONLY (field_decl) = TREE_READONLY (field_type);
+ TREE_READONLY (field_decl) = TYPE_READONLY (field_type);
/* If FIELD_TYPE is BLKmode, we must ensure this is aligned to at least a
byte boundary since GCC cannot handle less-aligned BLKmode bitfields. */
diff --git a/gcc/ada/utils2.c b/gcc/ada/utils2.c
index 72ddfb12b9d..3c0e26b8da0 100644
--- a/gcc/ada/utils2.c
+++ b/gcc/ada/utils2.c
@@ -1234,7 +1234,7 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
else
{
result = fold (build1 (op_code, TREE_TYPE (type), operand));
- TREE_READONLY (result) = TREE_READONLY (TREE_TYPE (type));
+ TREE_READONLY (result) = TYPE_READONLY (TREE_TYPE (type));
}
side_effects
@@ -1521,7 +1521,7 @@ gnat_build_constructor (tree type, tree list)
TREE_CONSTANT (result) = allconstant;
TREE_STATIC (result) = allconstant;
TREE_SIDE_EFFECTS (result) = side_effects;
- TREE_READONLY (result) = TREE_READONLY (type);
+ TREE_READONLY (result) = TYPE_READONLY (type);
return result;
}
diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 871592a357f..de96be38030 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -3089,7 +3089,7 @@ build_compound_literal (tree type, tree init)
DECL_CONTEXT (decl) = current_function_decl;
TREE_USED (decl) = 1;
TREE_TYPE (decl) = type;
- TREE_READONLY (decl) = TREE_READONLY (type);
+ TREE_READONLY (decl) = TYPE_READONLY (type);
store_init_value (decl, init);
if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 9bd63e571a2..26b83419d84 100644
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -1003,8 +1003,10 @@ tree
decl_constant_value (tree decl)
{
if (/* Don't change a variable array bound or initial value to a constant
- in a place where a variable is invalid. */
+ in a place where a variable is invalid. Note that DECL_INITIAL
+ isn't valid for a PARM_DECL. */
current_function_decl != 0
+ && TREE_CODE (decl) != PARM_DECL
&& ! TREE_THIS_VOLATILE (decl)
&& TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
diff --git a/gcc/calls.c b/gcc/calls.c
index d8ffb058cb5..44d6360d9bf 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -726,10 +726,9 @@ flags_from_decl_or_type (tree exp)
flags |= ECF_NOTHROW;
if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
- flags |= ECF_LIBCALL_BLOCK;
+ flags |= ECF_LIBCALL_BLOCK | ECF_CONST;
}
-
- if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
+ else if (TYPE_P (exp) && TYPE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
flags |= ECF_CONST;
if (TREE_THIS_VOLATILE (exp))
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 73aa9144902..515f6feb9b3 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2004-04-05 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * init.c (decl_constant_value): Don't look at DECL_INITIAL
+ of PARM_DECL.
+ * tree.c (bot_manip, build_min): Don't look at TREE_CONSTANT
+ or TREE_SIDE_EFFECTS of a type.
+
2004-04-02 Nathan Sidwell <nathan@codesourcery.com>
PR c++/14007
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index efc9a1323e1..e9142b775e0 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -1623,6 +1623,7 @@ decl_constant_value (tree decl)
/* And so are variables with a 'const' type -- unless they
are also 'volatile'. */
|| CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (decl)))
+ && TREE_CODE (decl) != PARM_DECL
&& DECL_INITIAL (decl)
&& DECL_INITIAL (decl) != error_mark_node
/* This is invalid if initial value is not constant.
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index adf3b391114..8dd85eae80d 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -1186,7 +1186,7 @@ bot_manip (tree* tp, int* walk_subtrees, void* data)
splay_tree target_remap = ((splay_tree) data);
tree t = *tp;
- if (TREE_CONSTANT (t))
+ if (!TYPE_P (t) && TREE_CONSTANT (t))
{
/* There can't be any TARGET_EXPRs or their slot variables below
this point. We used to check !TREE_SIDE_EFFECTS, but then we
@@ -1327,7 +1327,7 @@ build_min (enum tree_code code, tree tt, ...)
{
tree x = va_arg (p, tree);
TREE_OPERAND (t, i) = x;
- if (x && TREE_SIDE_EFFECTS (x))
+ if (x && !TYPE_P (x) && TREE_SIDE_EFFECTS (x))
TREE_SIDE_EFFECTS (t) = 1;
}
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 399bf2310ba..9a5533ce14e 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -1504,7 +1504,7 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
RTX_UNCHANGING_P (ref)
|= ((lang_hooks.honor_readonly
- && (TYPE_READONLY (type) || TREE_READONLY (t)))
+ && (TYPE_READONLY (type) || (t != type && TREE_READONLY (t))))
|| (! TYPE_P (t) && TREE_CONSTANT (t)));
MEM_POINTER (ref) = POINTER_TYPE_P (type);
diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c
index 8c65f08257b..1d89ad61034 100644
--- a/gcc/objc/objc-act.c
+++ b/gcc/objc/objc-act.c
@@ -8099,9 +8099,9 @@ adorn_decl (tree decl, char *str)
else if (code == POINTER_TYPE)
{
strcpy (tmpbuf, "*");
- if (TREE_READONLY (decl) || TYPE_VOLATILE (decl))
+ if (TYPE_READONLY (decl) || TYPE_VOLATILE (decl))
{
- if (TREE_READONLY (decl))
+ if (TYPE_READONLY (decl))
strcat (tmpbuf, " const");
if (TYPE_VOLATILE (decl))
strcat (tmpbuf, " volatile");
@@ -8305,7 +8305,7 @@ gen_declspecs (tree declspecs, char *buf, int raw)
else
{
/* Type qualifiers. */
- if (TREE_READONLY (declspecs))
+ if (TYPE_READONLY (declspecs))
strcat (buf, "const ");
if (TYPE_VOLATILE (declspecs))
strcat (buf, "volatile ");
diff --git a/gcc/print-tree.c b/gcc/print-tree.c
index 2fe09967d74..9dd9aaa2cd6 100644
--- a/gcc/print-tree.c
+++ b/gcc/print-tree.c
@@ -245,11 +245,12 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
indent_to (file, indent + 3);
}
- if (TREE_SIDE_EFFECTS (node))
+ if (!TYPE_P (node) && TREE_SIDE_EFFECTS (node))
fputs (" side-effects", file);
- if (TREE_READONLY (node))
+
+ if (TYPE_P (node) ? TYPE_READONLY (node) : TREE_READONLY (node))
fputs (" readonly", file);
- if (TREE_CONSTANT (node))
+ if (!TYPE_P (node) && TREE_CONSTANT (node))
fputs (" constant", file);
if (TREE_ADDRESSABLE (node))
fputs (" addressable", file);
diff --git a/gcc/tree.c b/gcc/tree.c
index 7d5e6d5b600..205db3f4bbf 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -2402,7 +2402,7 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
TREE_TYPE (t) = type;
TREE_COMPLEXITY (t) = 0;
TREE_OPERAND (t, 0) = node;
- if (node && first_rtl_op (code) != 0)
+ if (node && !TYPE_P (node) && first_rtl_op (code) != 0)
{
TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
TREE_READONLY (t) = TREE_READONLY (node);
@@ -2456,7 +2456,8 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
break;
default:
- if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
+ if (TREE_CODE_CLASS (code) == '1' && node && !TYPE_P (node)
+ && TREE_CONSTANT (node))
TREE_CONSTANT (t) = 1;
break;
}
@@ -2467,7 +2468,7 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
#define PROCESS_ARG(N) \
do { \
TREE_OPERAND (t, N) = arg##N; \
- if (arg##N && fro > N) \
+ if (arg##N &&!TYPE_P (arg##N) && fro > N) \
{ \
if (TREE_SIDE_EFFECTS (arg##N)) \
side_effects = 1; \
@@ -2742,7 +2743,8 @@ build_expr_wfl (tree node, const char *file, int line, int col)
}
EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
- if (node)
+
+ if (node && !TYPE_P (node))
{
TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
TREE_TYPE (wfl) = TREE_TYPE (node);
diff --git a/gcc/tree.h b/gcc/tree.h
index c2138dc44fc..34e6f45f4f2 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -54,6 +54,10 @@ enum tree_code {
extern const char tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
+/* Returns nonzero iff CLASS is not the tree code of a type. */
+
+#define IS_NON_TYPE_CODE_CLASS(CLASS) (strchr ("xbcdr<12se", (CLASS)) != 0)
+
/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
@@ -159,15 +163,16 @@ struct tree_common GTY(())
unsigned readonly_flag : 1;
unsigned unsigned_flag : 1;
unsigned asm_written_flag: 1;
- unsigned unused_0 : 1;
-
unsigned used_flag : 1;
+
unsigned nothrow_flag : 1;
unsigned static_flag : 1;
unsigned public_flag : 1;
unsigned private_flag : 1;
unsigned protected_flag : 1;
unsigned deprecated_flag : 1;
+
+ unsigned unused_0 : 1;
unsigned unused_1 : 1;
unsigned lang_flag_0 : 1;
@@ -240,6 +245,8 @@ struct tree_common GTY(())
TREE_SIDE_EFFECTS in
all expressions
+ all decls
+ all constants
volatile_flag:
@@ -259,6 +266,8 @@ struct tree_common GTY(())
TREE_CONSTANT in
all expressions
+ all decls
+ all constants
unsigned_flag:
@@ -365,7 +374,16 @@ struct tree_common GTY(())
({ const tree __t = (T); \
char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
if (!IS_EXPR_CODE_CLASS (__c)) \
- tree_class_check_failed (__t, 'e', __FILE__, __LINE__, \
+ tree_class_check_failed (__t, 'E', __FILE__, __LINE__, \
+ __FUNCTION__); \
+ __t; })
+
+/* These checks have to be special cased. */
+#define NON_TYPE_CHECK(T) __extension__ \
+({ const tree __t = (T); \
+ char const __c = TREE_CODE_CLASS (TREE_CODE (__t)); \
+ if (!IS_NON_TYPE_CODE_CLASS (__c)) \
+ tree_class_check_failed (__t, 'T', __FILE__, __LINE__, \
__FUNCTION__); \
__t; })
@@ -448,6 +466,7 @@ extern void tree_operand_check_failed (int, enum tree_code,
#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
#define TREE_CLASS_CHECK(T, CODE) (T)
#define EXPR_CHECK(T) (T)
+#define NON_TYPE_CHECK(T) (T)
#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
@@ -677,12 +696,13 @@ extern void tree_operand_check_failed (int, enum tree_code,
for this name in an inner scope. */
#define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
-/* In any expression, 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 reference to a volatile variable.
- In a ..._DECL, this is set only if the declaration said `volatile'. */
-#define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_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
+ reference to a volatile variable. In a ..._DECL, this is set only if the
+ declaration said `volatile'. This will never be set for a constant. */
+#define TREE_SIDE_EFFECTS(NODE) \
+ (NON_TYPE_CHECK (NODE)->common.side_effects_flag)
/* Nonzero means this expression is volatile in the C sense:
its address should be of type `volatile WHATEVER *'.
@@ -697,20 +717,15 @@ extern void tree_operand_check_failed (int, enum tree_code,
#define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)
/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
- nonzero means it may not be the lhs of an assignment.
- In a ..._TYPE node, means this type is const-qualified
- (but the macro TYPE_READONLY should be used instead of this macro
- when the node is a type). */
-#define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
+ nonzero means it may not be the lhs of an assignment. */
+#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->common.readonly_flag)
/* Nonzero if NODE is a _DECL with TREE_READONLY set. */
-#define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
+#define TREE_READONLY_DECL_P(NODE) (DECL_P (NODE) && TREE_READONLY (NODE))
-/* Value of expression is constant.
- Always appears in all ..._CST nodes.
- May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR
- if the value is constant. */
-#define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
+/* Value of expression is constant. Always on in all ..._CST nodes. May
+ also appear in an expression or decl where the value is constant. */
+#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->common.constant_flag)
/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
#define DECL_UNSIGNED(NODE) (DECL_CHECK (NODE)->common.unsigned_flag)
@@ -1446,7 +1461,9 @@ struct tree_type GTY(())
For a VAR_DECL, holds the initial value.
For a PARM_DECL, not used--default
values for parameters are encoded in the type of the function,
- not in the PARM_DECL slot. */
+ not in the PARM_DECL slot.
+
+ ??? Need to figure out some way to check this isn't a PARM_DECL. */
#define DECL_INITIAL(NODE) (DECL_CHECK (NODE)->decl.initial)
/* For a PARM_DECL, records the data type used to pass the argument,
which may be different from the type seen in the program. */
OpenPOWER on IntegriCloud