This makes use of native_encode/interpret_expr to do $subject.
Pretty straight-forward and something value-numbering already
does. Not sure what a good upper bound for the encode buffer
size should be - I suppose at some point we should teach
encode to skip uninteresting start bytes (and teach it to
interpret CONSTRUCTORs - the single major missing feature).
Bootstrap and regtest running on x86_64-unknown-linux-gnu.
Richard.
2012-03-16 Richard Guenther <rguent...@suse.de>
* fold-const.c (native_interpret_expr): Also support POINTER_TYPE
and REFERENCE_TYPE interpretations.
(can_native_interpret_type_p): New function.
(fold_ternary_loc): Use native encode/interpret to fold
BIT_FIELD_REFs of constants.
Index: gcc/fold-const.c
===================================================================
*** gcc/fold-const.c (revision 185465)
--- gcc/fold-const.c (working copy)
*************** native_interpret_expr (tree type, const
*** 7530,7535 ****
--- 7530,7537 ----
case INTEGER_TYPE:
case ENUMERAL_TYPE:
case BOOLEAN_TYPE:
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
return native_interpret_int (type, ptr, len);
case REAL_TYPE:
*************** native_interpret_expr (tree type, const
*** 7546,7551 ****
--- 7548,7574 ----
}
}
+ /* Returns true if we can interpret the contents of a native encoding
+ as TYPE. */
+
+ static bool
+ can_native_interpret_type_p (tree type)
+ {
+ switch (TREE_CODE (type))
+ {
+ case INTEGER_TYPE:
+ case ENUMERAL_TYPE:
+ case BOOLEAN_TYPE:
+ case POINTER_TYPE:
+ case REFERENCE_TYPE:
+ case REAL_TYPE:
+ case COMPLEX_TYPE:
+ case VECTOR_TYPE:
+ return true;
+ default:
+ return false;
+ }
+ }
/* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
TYPE at compile-time. If we're unable to perform the conversion
*************** fold_ternary_loc (location_t loc, enum t
*** 13945,13950 ****
--- 14004,14043 ----
&& integer_zerop (op2))
return fold_convert_loc (loc, type, arg0);
+ /* On constants we can use native encode/interpret to constant
+ fold (nearly) all BIT_FIELD_REFs. */
+ if (CONSTANT_CLASS_P (arg0)
+ && can_native_interpret_type_p (type)
+ && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (arg0)), 1)
+ /* This limitation should not be necessary, we just need to
+ round this up to mode size. */
+ && tree_low_cst (op1, 1) % BITS_PER_UNIT == 0
+ /* Need bit-shifting of the buffer to relax the following. */
+ && tree_low_cst (op2, 1) % BITS_PER_UNIT == 0)
+ {
+ unsigned HOST_WIDE_INT bitpos = tree_low_cst (op1, 2);
+ unsigned HOST_WIDE_INT bitsize = tree_low_cst (op1, 1);
+ unsigned HOST_WIDE_INT clen;
+ clen = tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (arg0)), 1);
+ /* ??? We cannot tell native_encode_expr to start at
+ some random byte only. So limit us to a reasonable amount
+ of work. */
+ if (clen <= 4096)
+ {
+ unsigned char *b = XALLOCAVEC (unsigned char, clen);
+ int len = native_encode_expr (arg0, b, clen);
+ if (len > 0
+ && len * BITS_PER_UNIT >= bitpos + bitsize)
+ {
+ tree v = native_interpret_expr (type,
+ b + bitpos / BITS_PER_UNIT,
+ bitsize / BITS_PER_UNIT);
+ if (v)
+ return v;
+ }
+ }
+ }
+
return NULL_TREE;
case FMA_EXPR:
