* tree.c (cp_valid_lang_attribute): Don't set CLASSTYPE_COM_INTERFACE

[pf3gnuchains/gcc-fork.git] / gcc / explow.c

diff --git a/gcc/explow.c b/gcc/explow.c
index 6ca93bc..a1c6380 100644 (file)
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -52,6 +52,10 @@ trunc_int_for_mode (c, mode)
 {
   int width = GET_MODE_BITSIZE (mode);
 
+  /* Canonicalize BImode to 0 and STORE_FLAG_VALUE.  */
+  if (mode == BImode)
+    return c & 1 ? STORE_FLAG_VALUE : 0;
+
   /* We clear out all bits that don't belong in MODE, unless they and our
      sign bit are all one.  So we get either a reasonable negative
      value or a reasonable unsigned value.  */
@@ -125,15 +129,10 @@ plus_constant_wide (x, c)
       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
          && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
        {
-         /* Any rtl we create here must go in a saveable obstack, since
-            we might have been called from within combine.  */
-         push_obstacks_nochange ();
-         rtl_in_saveable_obstack ();
          tem
            = force_const_mem (GET_MODE (x),
                               plus_constant (get_pool_constant (XEXP (x, 0)),
                                              c));
-         pop_obstacks ();
          if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
            return tem;
        }
@@ -396,6 +395,7 @@ convert_memory_address (to_mode, x)
       temp = gen_rtx_SYMBOL_REF (to_mode, XSTR (x, 0));
       SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
       CONSTANT_POOL_ADDRESS_P (temp) = CONSTANT_POOL_ADDRESS_P (x);
+      STRING_POOL_ADDRESS_P (temp) = STRING_POOL_ADDRESS_P (x);
       return temp;
 
     case CONST:
@@ -628,6 +628,27 @@ validize_mem (ref)
   return change_address (ref, GET_MODE (ref), XEXP (ref, 0));
 }
 \f
+/* Given REF, either a MEM or a REG, and T, either the type of X or
+   the expression corresponding to REF, set RTX_UNCHANGING_P if
+   appropriate.  */
+
+void
+maybe_set_unchanging (ref, t)
+     rtx ref;
+     tree t;
+{
+  /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
+     initialization is only executed once, or whose initializer always
+     has the same value.  Currently we simplify this to PARM_DECLs in the
+     first case, and decls with TREE_CONSTANT initializers in the second.  */
+  if ((TREE_READONLY (t) && DECL_P (t)
+       && (TREE_CODE (t) == PARM_DECL
+          || DECL_INITIAL (t) == NULL_TREE
+          || TREE_CONSTANT (DECL_INITIAL (t))))
+      || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
+    RTX_UNCHANGING_P (ref) = 1;
+}
+
 /* Given REF, a MEM, and T, either the type of X or the expression
    corresponding to REF, set the memory attributes.  OBJECTP is nonzero
    if we are making a new object of this type.  */
@@ -638,12 +659,24 @@ set_mem_attributes (ref, t, objectp)
      tree t;
      int objectp;
 {
-  tree type = TYPE_P (t) ? t : TREE_TYPE (t);
+  tree type;
+
+  /* It can happen that type_for_mode was given a mode for which there
+     is no language-level type.  In which case it returns NULL, which
+     we can see here.  */
+  if (t == NULL_TREE)
+    return;
+
+  type = TYPE_P (t) ? t : TREE_TYPE (t);
 
   /* Get the alias set from the expression or type (perhaps using a
      front-end routine) and then copy bits from the type.  */
+
+  /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY (type)
+     here, because, in C and C++, the fact that a location is accessed
+     through a const expression does not mean that the value there can
+     never change.  */
   MEM_ALIAS_SET (ref) = get_alias_set (t);
-  RTX_UNCHANGING_P (ref) = TYPE_READONLY (type);
   MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
 
@@ -657,8 +690,7 @@ set_mem_attributes (ref, t, objectp)
   if (TYPE_P (t))
     return;
 
-  if (TREE_READONLY (t) || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
-    RTX_UNCHANGING_P (ref) = 1;
+  maybe_set_unchanging (ref, t);
   if (TREE_THIS_VOLATILE (t))
     MEM_VOLATILE_P (ref) = 1;
 
@@ -810,8 +842,10 @@ force_not_mem (x)
      rtx x;
 {
   register rtx temp;
+
   if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
     return x;
+
   temp = gen_reg_rtx (GET_MODE (x));
   emit_move_insn (temp, x);
   return temp;