c-decl.c (build_compound_literal): Use TYPE_READONLY.

	* 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.

	* cp/init.c (decl_constant_value): Don't look at DECL_INITIAL
	of PARM_DECL.
	* cp/tree.c (bot_manip, build_min): Don't look at TREE_CONSTANT
	or TREE_SIDE_EFFECTS of a type.

	* ada/decl.c (gnat_to_gnu_entity): Use TYPE_READONLY.
	* ada/utils.c (create_field_decl): Likewise.
	* ada/utils2.c (build_unary_op, gnat_build_constructor): Likewise.

From-SVN: r80430

1 files changed, 38 insertions, 21 deletions

diff --git a/gcc/tree.h b/gcc/tree.h
index c2138dc..34e6f45 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.  */