Index: gcc/gimple.c
===================================================================
*** gcc/gimple.c.orig	2012-04-05 14:04:32.630714246 +0200
--- gcc/gimple.c	2012-04-05 14:05:06.477712225 +0200
*************** is_gimple_address (const_tree t)
*** 2742,2748 ****
        op = TREE_OPERAND (op, 0);
      }
  
!   if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF)
      return true;
  
    switch (TREE_CODE (op))
--- 2742,2748 ----
        op = TREE_OPERAND (op, 0);
      }
  
!   if (TREE_CODE (op) == MEM_REF)
      return true;
  
    switch (TREE_CODE (op))
*************** is_gimple_invariant_address (const_tree
*** 2778,2788 ****
      {
        const_tree op0 = TREE_OPERAND (op, 0);
        return (TREE_CODE (op0) == ADDR_EXPR
! 	      && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
! 		  || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
      }
  
!   return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
  }
  
  /* Return true if T is a gimple invariant address at IPA level
--- 2778,2787 ----
      {
        const_tree op0 = TREE_OPERAND (op, 0);
        return (TREE_CODE (op0) == ADDR_EXPR
! 	      && decl_address_invariant_p (TREE_OPERAND (op0, 0)));
      }
  
!   return decl_address_invariant_p (op);
  }
  
  /* Return true if T is a gimple invariant address at IPA level
*************** is_gimple_ip_invariant_address (const_tr
*** 2804,2814 ****
      {
        const_tree op0 = TREE_OPERAND (op, 0);
        return (TREE_CODE (op0) == ADDR_EXPR
! 	      && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
! 		  || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0))));
      }
  
!   return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op);
  }
  
  /* Return true if T is a GIMPLE minimal invariant.  It's a restricted
--- 2803,2812 ----
      {
        const_tree op0 = TREE_OPERAND (op, 0);
        return (TREE_CODE (op0) == ADDR_EXPR
! 	      && decl_address_ip_invariant_p (TREE_OPERAND (op0, 0)));
      }
  
!   return decl_address_ip_invariant_p (op);
  }
  
  /* Return true if T is a GIMPLE minimal invariant.  It's a restricted
*************** is_gimple_id (tree t)
*** 2906,2914 ****
    return (is_gimple_variable (t)
  	  || TREE_CODE (t) == FUNCTION_DECL
  	  || TREE_CODE (t) == LABEL_DECL
! 	  || TREE_CODE (t) == CONST_DECL
! 	  /* Allow string constants, since they are addressable.  */
! 	  || TREE_CODE (t) == STRING_CST);
  }
  
  /* Return true if T is a non-aggregate register variable.  */
--- 2904,2910 ----
    return (is_gimple_variable (t)
  	  || TREE_CODE (t) == FUNCTION_DECL
  	  || TREE_CODE (t) == LABEL_DECL
! 	  || TREE_CODE (t) == CONST_DECL);
  }
  
  /* Return true if T is a non-aggregate register variable.  */
*************** is_gimple_mem_ref_addr (tree t)
*** 3009,3016 ****
    return (is_gimple_reg (t)
  	  || TREE_CODE (t) == INTEGER_CST
  	  || (TREE_CODE (t) == ADDR_EXPR
! 	      && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
! 		  || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
  }
  
  
--- 3005,3011 ----
    return (is_gimple_reg (t)
  	  || TREE_CODE (t) == INTEGER_CST
  	  || (TREE_CODE (t) == ADDR_EXPR
! 	      && decl_address_invariant_p (TREE_OPERAND (t, 0))));
  }
  
  
Index: gcc/gimplify.c
===================================================================
*** gcc/gimplify.c.orig	2012-04-05 14:05:04.000000000 +0200
--- gcc/gimplify.c	2012-04-05 14:05:13.849711785 +0200
*************** gimplify_compound_lval (tree *expr_p, gi
*** 2130,2136 ****
       so as to match the min_lval predicate.  Failure to do so may result
       in the creation of large aggregate temporaries.  */
    tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
! 			fallback | fb_lvalue);
    ret = MIN (ret, tret);
  
    /* And finally, the indices and operands to BIT_FIELD_REF.  During this
--- 2130,2137 ----
       so as to match the min_lval predicate.  Failure to do so may result
       in the creation of large aggregate temporaries.  */
    tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
! 			VEC_length (tree, stack) != 0
! 			? fb_lvalue : fallback | fb_lvalue);
    ret = MIN (ret, tret);
  
    /* And finally, the indices and operands to BIT_FIELD_REF.  During this
*************** gimplify_expr (tree *expr_p, gimple_seq
*** 7086,7092 ****
  	case STRING_CST:
  	case COMPLEX_CST:
  	case VECTOR_CST:
! 	  ret = GS_ALL_DONE;
  	  break;
  
  	case CONST_DECL:
--- 7087,7102 ----
  	case STRING_CST:
  	case COMPLEX_CST:
  	case VECTOR_CST:
! 	  if (fallback & fb_rvalue)
! 	    ret = GS_ALL_DONE;
! 	  else
! 	    {
! 	      tree cdecl = build_decl (UNKNOWN_LOCATION, CONST_DECL,
! 				       NULL_TREE, TREE_TYPE (*expr_p));
! 	      DECL_INITIAL (cdecl) = *expr_p;
! 	      *expr_p = cdecl;
! 	      ret = GS_OK;
! 	    }
  	  break;
  
  	case CONST_DECL: