On Thu, Oct 15, 2026 at 10:00 AM Jakub Jelinek <[email protected]> wrote:
>
> Hi!
>
> When writing the PR127685 fix/workaround, I've noticed the comment
> about RAW_DATA_CST and decided to implement it. WHen playing with
> testcases, I've noticed it doesn't handle even more important case,
> STRING_CST.
> RAW_DATA_CST is less important because it usually appears only for
> larger chunks, CPP_EMBED should usually appear for 64+ bytes in
> the #embed directive and being turned into RAW_DATA_CST, similarly the
> optimizations to turn large array initializers into RAW_DATA_CST usually
> need 64+ bytes or more. Sure, e.g. C designated initializers then can
> break it into smaller pieces, down to even 2 bytes in it, but
> the vrp-cstload-limit param has 255 as the upper limit (why?) and
> checks the whole size of the corresponding complete object, not even
> its subobject, so to handle RAW_DATA_CST, one needs to bump the limit I
> think.
> On the other side, the C/C++ braced_list_to_string optimization can
> turn initializers like {,un}signed char xyz[] = { 1, 2, 3 };
> into = "\1\2\3", even for much smaller sizes.
>
> Anyway, both of these IMHO need to be handled inside of
> accumulate_range_from_array_ref, because that is where we know the
> indexes, can check if a specific byte in those intersects the index range
> and in that case, we don't need to build_int_cst just to throw it away
> and can just create a wide_int and union that. In both of these cases
> we can do this only for the end of the component path and have to verify
> m_type is integral and with CHAR_BIT precision. It can be either
> signed or unsigned, we need to either sign or zero extend the host byte
> from STRING_CST or RAW_DATA_CST when creating the wide_int.
>
> Or shall I instead of the intersects_p (idx_r, next, next) and
> intersects_p (idx_r, lo, lo) checks call idx_r.contains_p (next)
> and idx_r.contains (lo)? And/or change the intersects_p function to
> optimize for the common case, so if (lo == hi) return r.contains (lo);
> first before doing it the slower way?
>
> Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
>
> 2026-10-15 Jakub Jelinek <[email protected]>
>
> PR tree-optimization/127879
> * gimple-range-fold.cc (ctor_ref_range::accumulate_range): Remove
> comment about RAW_DATA_CST. Allow also STRING_CST, not just
> CONSTRUCTOR.
> (ctor_ref_range::accumulate_range_from_component_ref): Punt if
> init is not a CONSTRUCTOR.
> (ctor_ref_range::accumulate_range_from_array_ref): Handle
> init being a STRING_CST. Handle RAW_DATA_CSTs inside of a
> CONSTRUCTOR.
> (fold_using_range::range_from_readonly_var): Allow ctor being
> a STRING_CST, rather than only a CONSTRUCTOR.
>
> * gcc.dg/tree-ssa/vrp-from-cst-agg-14.c: New test.
> * gcc.dg/tree-ssa/vrp-from-cst-agg-15.c: New test.
> * gcc.dg/tree-ssa/vrp-from-cst-agg-16.c: New test.
> * gcc.dg/tree-ssa/vrp-from-cst-agg-17.c: New test.
> * gcc.dg/tree-ssa/vrp-from-cst-agg-18.c: New test.
> * gcc.dg/tree-ssa/vrp-from-cst-agg-19.c: New test.
>
> --- a/gcc/gimple-range-fold.cc 2026-10-13 08:39:10.033278759 +0200
> +++ b/gcc/gimple-range-fold.cc 2026-10-14 10:20:24.476947435 +0200
> @@ -1041,8 +1041,7 @@ ctor_ref_range::accumulate_range (tree i
> {
> if (i == m_component_path.length ())
> return accumulate_range_from_scalar (init);
> - /* TODO: Perhaps handle RAW_DATA_CST too. */
> - if (TREE_CODE (init) != CONSTRUCTOR)
> + if (TREE_CODE (init) != CONSTRUCTOR && TREE_CODE (init) != STRING_CST)
> return false;
>
> tree ref = m_component_path[i];
> @@ -1112,6 +1111,8 @@ ctor_ref_range::accumulate_range_from_co
> {
> unsigned ix;
> tree index, val;
> + if (TREE_CODE (init) != CONSTRUCTOR)
> + return false;
> FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), ix, index, val)
> {
> if (index != fld)
> @@ -1182,6 +1183,29 @@ ctor_ref_range::accumulate_range_from_ar
> unsigned ix;
> tree index, val;
>
> + if (TREE_CODE (init) == STRING_CST)
> + {
> + if (i != m_component_path.length ()
> + || !INTEGRAL_TYPE_P (m_type)
> + || TYPE_PRECISION (m_type) != CHAR_BIT
> + || !useless_type_conversion_p (m_type, TREE_TYPE (TREE_TYPE (init)))
> + || wi::gtu_p (max + 1 - min, TREE_STRING_LENGTH (init)))
> + return false;
> + for (int n = 0; wi::leu_p (next, max); ++n, next = next + 1)
> + if (intersects_p (idx_r, next, next))
Surely walking the idx_r representation (which is an ordered set of intervals?)
would be more efficient?
> + {
> + wide_int wi_cst;
> + if (TYPE_UNSIGNED (m_type))
> + wi_cst = wi::uhwi ((unsigned char) TREE_STRING_POINTER
> (init)[n],
> + CHAR_BIT);
> + else
> + wi_cst = wi::shwi ((signed char) TREE_STRING_POINTER (init)[n],
> + CHAR_BIT);
> + m_r.union_ (int_range<1> (m_type, wi_cst, wi_cst));
and for the sake of efficiency collecting the unsigned chars visited
(256 bit sbitmap?) and unioning each duplicate at most once or even
building an irange from a sorted set of elements directly.
If we are talking about efficiency. I'd be fine with the existing
code - ISTR we have
an upper limit --param how many values we visit, but this doesn't
enforce it (param_vrp_cstload_limit)?
Richard.
> + }
> + return true;
> + }
> +
> // Build a range with the entire domain, and take out any elements which
> are
> // initialized. If there's anything left in that range, it means there are
> // missing elements and we should add a [0, 0] to the final range.
> @@ -1208,7 +1232,34 @@ ctor_ref_range::accumulate_range_from_ar
> missing.intersect (int_range<2> (type, lo, hi, VR_ANTI_RANGE));
> next = wi::add (hi, 1);
>
> - if (intersects_p (idx_r, lo, hi) && !accumulate_range (val, i))
> + if (!intersects_p (idx_r, lo, hi))
> + continue;
> +
> + if (TREE_CODE (val) == RAW_DATA_CST)
> + {
> + if (i != m_component_path.length ()
> + || !INTEGRAL_TYPE_P (m_type)
> + || TYPE_PRECISION (m_type) != CHAR_BIT
> + || !useless_type_conversion_p (m_type,
> + TREE_TYPE (val)))
> + return false;
> +
> + for (int n = 0; wi::leu_p (lo, hi); ++n, lo = lo + 1)
> + if (intersects_p (idx_r, lo, lo))
> + {
> + wide_int wi_cst;
> + if (TYPE_UNSIGNED (m_type))
> + wi_cst = wi::uhwi (RAW_DATA_UCHAR_ELT (val, n),
> + CHAR_BIT);
> + else
> + wi_cst = wi::shwi (RAW_DATA_SCHAR_ELT (val, n),
> + CHAR_BIT);
> + m_r.union_ (int_range<1> (m_type, wi_cst, wi_cst));
> + }
> + continue;
> + }
> +
> + if (!accumulate_range (val, i))
> return false;
> }
>
> @@ -1278,7 +1329,8 @@ fold_using_range::range_from_readonly_va
> the right part of the constructor then. */
> tree ctor = ctor_for_folding (t);
> if (!ctor
> - || TREE_CODE (ctor) != CONSTRUCTOR)
> + || (TREE_CODE (ctor) != CONSTRUCTOR
> + && TREE_CODE (ctor) != STRING_CST))
> return false;
>
> value_range tmp (type);
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-14.c 2026-10-14
> 10:36:44.663663527 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-14.c 2026-10-14
> 10:43:14.877374484 +0200
> @@ -0,0 +1,65 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized --param vrp-cstload-limit=255" }
> */
> +/* { dg-final { scan-tree-dump-times "PHI <(?:-1\\\(\[0-9]*\\\),
> 1|1\\\(\[0-9]*\\\), -1)\\\(\[0-9]*\\\)>" 4 "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = \[abc]\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = d.b\\\[" "optimized" } } */
> +
> +const unsigned char a[] = { 100, 108, 48, 49, 50, 51, 52, 53, 54, 55, 56,
> 57, 0, 24, 18, 35, 98 };
> +const unsigned char b[] = { 100, 108, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 0, 24, 18, 35, 98 };
> +const struct { int a; unsigned char b; } c[] = { { 0, 100 }, { 0, 108 }, {
> 0, 48 }, { 0, 49 }, { 0, 50 }, { 0, 51 },
> + { 0, 52 }, { 0, 53 }, { 0,
> 54 }, { 0, 55 }, { 0, 56 }, { 0, 57 },
> + { 0, 0 }, { 0, 24 }, { 0, 18
> }, { 0, 35 }, { 0, 98 } };
> +const struct { int a; unsigned char b[]; } d = { 0, { 100, 108, 48, 49, 50,
> 51, 52, 53, 54, 55, 56, 57, 0, 24, 18, 35, 98 } };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= 48 && a[x] <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 220)
> + return -1;
> + if (b[x] >= 48 && b[x] <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +baz (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (c[x].b >= 48 && c[x].b <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +qux (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (d.b[x] >= 48 && d.b[x] <= 57)
> + return 1;
> + return 0;
> +}
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-15.c 2026-10-14
> 10:44:04.801697802 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-15.c 2026-10-14
> 10:46:12.626965130 +0200
> @@ -0,0 +1,29 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized -fexec-charset=UTF-8" } */
> +/* { dg-final { scan-tree-dump-times "PHI <(?:-1\\\(\[0-9]*\\\),
> 1|1\\\(\[0-9]*\\\), -1)\\\(\[0-9]*\\\)>" 2 "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = a\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = b.b\\\[" "optimized" } } */
> +
> +const unsigned char a[] = " !0123456789\0{}~";
> +const struct { int a; unsigned char b[]; } b = { 0, " !0123456789\0{}~" };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= '0' && a[x] <= '9')
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (b.b[x] >= '0' && b.b[x] <= '9')
> + return 1;
> + return 0;
> +}
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-16.c 2026-10-14
> 10:58:17.356141325 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-16.c 2026-10-14
> 11:01:27.370565646 +0200
> @@ -0,0 +1,29 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +/* { dg-final { scan-tree-dump-times "PHI <(?:-1\\\(\[0-9]*\\\),
> 1|1\\\(\[0-9]*\\\), -1)\\\(\[0-9]*\\\)>" 2 "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = a\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump-not " = b.b\\\[" "optimized" } } */
> +
> +const signed char a[] = { 28, -36, -2, -1, 2, 4, -3, -4, 1, 3, 0, 5, -37, 29
> };
> +const struct { int a; signed char b[]; } b = { 0, { 28, -36, -2, -1, 2, 4,
> -3, -4, 1, 3, 0, 5, -37, 29 } };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= -4 && a[x] <= 5)
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (b.b[x] >= -4 && b.b[x] <= 5)
> + return 1;
> + return 0;
> +}
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-17.c 2026-10-14
> 11:02:04.307065113 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-17.c 2026-10-14
> 11:03:26.765947833 +0200
> @@ -0,0 +1,66 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized --param vrp-cstload-limit=255" }
> */
> +/* { dg-final { scan-tree-dump " = a\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump " = b\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump " = c\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump " = d.b\\\[" "optimized" } } */
> +
> +const unsigned char a[] = { 100, 108, 48, 49, 50, 51, 52, 53, 58, 55, 56,
> 57, 0, 24, 18, 35, 98 };
> +const unsigned char b[] = { 100, 108, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 47, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49,
> 50, 51, 52, 53, 54, 55, 56, 57,
> + 0, 24, 18, 35, 98 };
> +const struct { int a; unsigned char b; } c[] = { { 0, 100 }, { 0, 108 }, {
> 0, 48 }, { 0, 49 }, { 0, 50 }, { 0, 51 },
> + { 0, 52 }, { 0, 58 }, { 0,
> 54 }, { 0, 55 }, { 0, 56 }, { 0, 57 },
> + { 0, 0 }, { 0, 24 }, { 0, 18
> }, { 0, 35 }, { 0, 98 } };
> +const struct { int a; unsigned char b[]; } d = { 0, { 100, 108, 48, 49, 50,
> 51, 47, 53, 54, 55, 56, 57, 0, 24, 18, 35, 98 } };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= 48 && a[x] <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 220)
> + return -1;
> + if (b[x] >= 48 && b[x] <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +baz (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (c[x].b >= 48 && c[x].b <= 57)
> + return 1;
> + return 0;
> +}
> +
> +int
> +qux (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (d.b[x] >= 48 && d.b[x] <= 57)
> + return 1;
> + return 0;
> +}
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-18.c 2026-10-14
> 11:03:46.323682837 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-18.c 2026-10-14
> 11:04:14.952294928 +0200
> @@ -0,0 +1,28 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized -fexec-charset=UTF-8" } */
> +/* { dg-final { scan-tree-dump " = a\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump " = b.b\\\[" "optimized" } } */
> +
> +const unsigned char a[] = " !012345+789\0{}~";
> +const struct { int a; unsigned char b[]; } b = { 0, " !01234567+9\0{}~" };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= '0' && a[x] <= '9')
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (b.b[x] >= '0' && b.b[x] <= '9')
> + return 1;
> + return 0;
> +}
> --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-19.c 2026-10-14
> 11:04:26.179142809 +0200
> +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-from-cst-agg-19.c 2026-10-14
> 11:04:45.909875465 +0200
> @@ -0,0 +1,28 @@
> +/* PR tree-optimization/127879 */
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -fdump-tree-optimized" } */
> +/* { dg-final { scan-tree-dump " = a\\\[" "optimized" } } */
> +/* { dg-final { scan-tree-dump " = b.b\\\[" "optimized" } } */
> +
> +const signed char a[] = { 28, -36, -2, -1, 2, 4, -3, -4, 1, 3, 0, -5, -37,
> 29 };
> +const struct { int a; signed char b[]; } b = { 0, { 28, -36, -2, -1, 2, 4,
> -3, -4, 1, 3, 0, -5, -37, 29 } };
> +
> +int
> +foo (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (a[x] >= -4 && a[x] <= 5)
> + return 1;
> + return 0;
> +}
> +
> +int
> +bar (int x)
> +{
> + if (x < 2 || x >= 12)
> + return -1;
> + if (b.b[x] >= -4 && b.b[x] <= 5)
> + return 1;
> + return 0;
> +}
>
> Jakub
>
