OSDN Git Service

2008-03-06 Richard Guenther <rguenther@suse.de>
authorrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 6 Mar 2008 12:08:23 +0000 (12:08 +0000)
committerrguenth <rguenth@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 6 Mar 2008 12:08:23 +0000 (12:08 +0000)
* tree.def (BIT_FIELD_REF): Constrain result type and its precision.
* tree-cfg.c (verify_expr): Verify BIT_FIELD_REF constraints on
result type and precision.
* expr.c (get_inner_reference): Set unsignedp based on the result
type of BIT_FIELD_REF.
* tree.h (BIT_FIELD_REF_UNSIGNED): Remove.
* tree-sra.c (instantiate_element): Do not set BIT_FIELD_REF_UNSIGNED.
(try_instantiate_multiple_fields): Likewise.  Use the correct type
for BIT_FIELD_REF.
(sra_build_assignment): Likewise.
(sra_build_elt_assignment): Likewise.
(sra_explode_bitfield_assignment): Likewise.
* print-tree.c (print_node): Do not check BIT_FIELD_REF_UNSIGNED.
* tree-vect-transform.c (vect_create_epilog_for_reduction): Do not
set BIT_FIELD_REF_UNSIGNED.
(vectorizable_load): Likewise.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@132969 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/ChangeLog
gcc/expr.c
gcc/print-tree.c
gcc/tree-cfg.c
gcc/tree-sra.c
gcc/tree-vect-transform.c
gcc/tree.def
gcc/tree.h

index f87ec3b..62d7822 100644 (file)
@@ -1,3 +1,22 @@
+2008-03-06  Richard Guenther  <rguenther@suse.de>
+
+       * tree.def (BIT_FIELD_REF): Constrain result type and its precision.
+       * tree-cfg.c (verify_expr): Verify BIT_FIELD_REF constraints on
+       result type and precision.
+       * expr.c (get_inner_reference): Set unsignedp based on the result
+       type of BIT_FIELD_REF.
+       * tree.h (BIT_FIELD_REF_UNSIGNED): Remove.
+       * tree-sra.c (instantiate_element): Do not set BIT_FIELD_REF_UNSIGNED.
+       (try_instantiate_multiple_fields): Likewise.  Use the correct type
+       for BIT_FIELD_REF.
+       (sra_build_assignment): Likewise.
+       (sra_build_elt_assignment): Likewise.
+       (sra_explode_bitfield_assignment): Likewise.
+       * print-tree.c (print_node): Do not check BIT_FIELD_REF_UNSIGNED.
+       * tree-vect-transform.c (vect_create_epilog_for_reduction): Do not
+       set BIT_FIELD_REF_UNSIGNED.
+       (vectorizable_load): Likewise.
+
 2008-03-06  Andreas Krebbel  <krebbel1@de.ibm.com>
 
        * cse.c (cse_extended_basic_block): Invalidate artificial defs
index 79a039a..2cd6e62 100644 (file)
@@ -5893,7 +5893,8 @@ get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
   else if (TREE_CODE (exp) == BIT_FIELD_REF)
     {
       size_tree = TREE_OPERAND (exp, 1);
-      *punsignedp = BIT_FIELD_REF_UNSIGNED (exp);
+      *punsignedp = (! INTEGRAL_TYPE_P (TREE_TYPE (exp))
+                    || TYPE_UNSIGNED (TREE_TYPE (exp)));
 
       /* For vector types, with the correct size of access, use the mode of
         inner type.  */
index 7df8161..889f1c5 100644 (file)
@@ -676,8 +676,6 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
     case tcc_reference:
     case tcc_statement:
     case tcc_vl_exp:
-      if (TREE_CODE (node) == BIT_FIELD_REF && BIT_FIELD_REF_UNSIGNED (node))
-       fputs (" unsigned", file);
       if (TREE_CODE (node) == BIND_EXPR)
        {
          print_node (file, "vars", TREE_OPERAND (node, 0), indent + 4);
index 71a6c9a..f98c684 100644 (file)
@@ -3277,6 +3277,22 @@ verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
                  error ("invalid position or size operand to BIT_FIELD_REF");
                  return t;
                }
+             else if (INTEGRAL_TYPE_P (TREE_TYPE (t))
+                      && (TYPE_PRECISION (TREE_TYPE (t))
+                          != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
+               {
+                 error ("integral result type precision does not match "
+                        "field size of BIT_FIELD_REF");
+                 return t;
+               }
+             if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
+                 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t)))
+                     != TREE_INT_CST_LOW (TREE_OPERAND (t, 1))))
+               {
+                 error ("mode precision of non-integral result does not "
+                        "match field size of BIT_FIELD_REF");
+                 return t;
+               }
            }
 
          t = TREE_OPERAND (t, 0);
index 1f2d6c2..45142e8 100644 (file)
@@ -1280,9 +1280,6 @@ instantiate_element (struct sra_elt *elt)
                                               TYPE_SIZE (elt->type),
                                               DECL_SIZE (var))
                                 : bitsize_int (0));
-      if (!INTEGRAL_TYPE_P (elt->type)
-         || TYPE_UNSIGNED (elt->type))
-       BIT_FIELD_REF_UNSIGNED (elt->replacement) = 1;
     }
 
   /* For vectors, if used on the left hand side with BIT_FIELD_REF,
@@ -1677,12 +1674,17 @@ try_instantiate_multiple_fields (struct sra_elt *elt, tree f)
 
   /* Create the field group as a single variable.  */
 
-  type = lang_hooks.types.type_for_mode (mode, 1);
+  /* We used to create a type for the mode above, but size turns
+     to be out not of mode-size.  As we need a matching type
+     to build a BIT_FIELD_REF, use a nonstandard integer type as
+     fallback.  */
+  type = lang_hooks.types.type_for_size (size, 1);
+  if (!type || TYPE_PRECISION (type) != size)
+    type = build_nonstandard_integer_type (size, 1);
   gcc_assert (type);
   var = build3 (BIT_FIELD_REF, type, NULL_TREE,
                bitsize_int (size),
                bitsize_int (bit));
-  BIT_FIELD_REF_UNSIGNED (var) = 1;
 
   block = instantiate_missing_elements_1 (elt, var, type);
   gcc_assert (block && block->is_scalar);
@@ -1696,7 +1698,6 @@ try_instantiate_multiple_fields (struct sra_elt *elt, tree f)
                                   TREE_TYPE (block->element), var,
                                   bitsize_int (size),
                                   bitsize_int (bit & ~alchk));
-      BIT_FIELD_REF_UNSIGNED (block->replacement) = 1;
     }
 
   block->in_bitfld_block = 2;
@@ -1719,7 +1720,6 @@ try_instantiate_multiple_fields (struct sra_elt *elt, tree f)
                                   + (TREE_INT_CST_LOW
                                      (DECL_FIELD_BIT_OFFSET (f))))
                                  & ~alchk));
-      BIT_FIELD_REF_UNSIGNED (fld->replacement) = TYPE_UNSIGNED (field_type);
       fld->in_bitfld_block = 1;
     }
 
@@ -2141,7 +2141,8 @@ sra_build_assignment (tree dst, tree src)
       tree var, shift, width;
       tree utype, stype, stmp, utmp, dtmp;
       tree list, stmt;
-      bool unsignedp = BIT_FIELD_REF_UNSIGNED (src);
+      bool unsignedp = (INTEGRAL_TYPE_P (TREE_TYPE (src))
+                       ? TYPE_UNSIGNED (TREE_TYPE (src)) : true);
 
       var = TREE_OPERAND (src, 0);
       width = TREE_OPERAND (src, 1);
@@ -2491,6 +2492,7 @@ sra_build_elt_assignment (struct sra_elt *elt, tree src)
   if (elt->in_bitfld_block == 2
       && TREE_CODE (src) == BIT_FIELD_REF)
     {
+      tmp = src;
       cst = TYPE_SIZE (TREE_TYPE (var));
       cst2 = size_binop (MINUS_EXPR, TREE_OPERAND (src, 2),
                         TREE_OPERAND (dst, 2));
@@ -2536,8 +2538,7 @@ sra_build_elt_assignment (struct sra_elt *elt, tree src)
        }
       else
        {
-         src = fold_build3 (BIT_FIELD_REF, TREE_TYPE (var), src, cst, cst2);
-         BIT_FIELD_REF_UNSIGNED (src) = 1;
+         src = fold_convert (TREE_TYPE (var), tmp);
        }
 
       return sra_build_assignment (var, src);
@@ -3014,6 +3015,8 @@ sra_explode_bitfield_assignment (tree var, tree vpos, bool to_var,
          type = TREE_TYPE (infld);
          if (TYPE_PRECISION (type) != TREE_INT_CST_LOW (flen))
            type = lang_hooks.types.type_for_size (TREE_INT_CST_LOW (flen), 1);
+         else
+           type = unsigned_type_for (type);
 
          if (TREE_CODE (infld) == BIT_FIELD_REF)
            {
@@ -3031,7 +3034,6 @@ sra_explode_bitfield_assignment (tree var, tree vpos, bool to_var,
            }
 
          infld = fold_build3 (BIT_FIELD_REF, type, infld, flen, fpos);
-         BIT_FIELD_REF_UNSIGNED (infld) = 1;
 
          invar = size_binop (MINUS_EXPR, flp.field_pos, bpos);
          if (flp.overlap_pos)
@@ -3039,7 +3041,6 @@ sra_explode_bitfield_assignment (tree var, tree vpos, bool to_var,
          invar = size_binop (PLUS_EXPR, invar, vpos);
 
          invar = fold_build3 (BIT_FIELD_REF, type, var, flen, invar);
-         BIT_FIELD_REF_UNSIGNED (invar) = 1;
 
          if (to_var)
            st = sra_build_bf_assignment (invar, infld);
index 883d745..a35e963 100644 (file)
@@ -2517,7 +2517,6 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt,
          vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
          rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
                         bitsize_zero_node);
-         BIT_FIELD_REF_UNSIGNED (rhs) = TYPE_UNSIGNED (scalar_type);
          epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs);
          new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
          GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp;
@@ -2532,7 +2531,6 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt,
              tree rhs = build3 (BIT_FIELD_REF, scalar_type, vec_temp, bitsize,
                                 bitpos);
                
-             BIT_FIELD_REF_UNSIGNED (rhs) = TYPE_UNSIGNED (scalar_type);
              epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs);
              new_name = make_ssa_name (new_scalar_dest, epilog_stmt);
              GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_name;
@@ -2568,7 +2566,6 @@ vect_create_epilog_for_reduction (tree vect_def, tree stmt,
        bitpos = bitsize_zero_node;
 
       rhs = build3 (BIT_FIELD_REF, scalar_type, new_temp, bitsize, bitpos);
-      BIT_FIELD_REF_UNSIGNED (rhs) = TYPE_UNSIGNED (scalar_type);
       epilog_stmt = build_gimple_modify_stmt (new_scalar_dest, rhs);
       new_temp = make_ssa_name (new_scalar_dest, epilog_stmt);
       GIMPLE_STMT_OPERAND (epilog_stmt, 0) = new_temp; 
@@ -5877,8 +5874,6 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt,
                  bitpos = bitsize_zero_node;
                  vec_inv = build3 (BIT_FIELD_REF, scalar_type, new_temp, 
                                                            bitsize, bitpos);
-                 BIT_FIELD_REF_UNSIGNED (vec_inv) = 
-                                                TYPE_UNSIGNED (scalar_type);
                  vec_dest = 
                        vect_create_destination_var (scalar_dest, NULL_TREE);
                  new_stmt = build_gimple_modify_stmt (vec_dest, vec_inv);
index aac9d56..4a55ee0 100644 (file)
@@ -391,8 +391,9 @@ DEFTREECODE (COMPONENT_REF, "component_ref", tcc_reference, 3)
    Operand 0 is the structure or union expression;
    operand 1 is a tree giving the constant number of bits being referenced;
    operand 2 is a tree giving the constant position of the first referenced bit.
-   The field can be either a signed or unsigned field;
-   BIT_FIELD_REF_UNSIGNED says which.  */
+   The result type width has to match the number of bits referenced.
+   If the result type is integral, its signedness specifies how it is extended
+   to its mode width.  */
 DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", tcc_reference, 3)
 
 /* The ordering of the following codes is optimized for the checking
index d59d3fa..de6654d 100644 (file)
@@ -542,8 +542,6 @@ struct gimple_stmt GTY(())
            all types
        DECL_UNSIGNED in
            all decls
-       BIT_FIELD_REF_UNSIGNED in
-           BIT_FIELD_REF
 
    asm_written_flag:
 
@@ -1301,10 +1299,6 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int,
 #define DECL_UNSIGNED(NODE) \
   (DECL_COMMON_CHECK (NODE)->base.unsigned_flag)
 
-/* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned.  */
-#define BIT_FIELD_REF_UNSIGNED(NODE) \
-  (BIT_FIELD_REF_CHECK (NODE)->base.unsigned_flag)
-
 /* In integral and pointer types, means an unsigned type.  */
 #define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.unsigned_flag)