Re: [PATCH] ipa: Remove ipa_bits

[Aldy Hernandez <aldyh@redhat.com>]

[-- Attachment #1: Type: text/plain, Size: 36541 bytes --]

On Thu, Oct 5, 2023, 8:26 a.m. Jakub Jelinek <jakub@redhat.com> wrote:

> Hi!
>
> The following patch removes ipa_bits struct pointer/vector from ipa
> jump functions and ipa cp transformations.
>
> The reason is because the struct uses widest_int to represent
> mask/value pair, which in the RFC patches to allow larger precisions
> for wide_int/widest_int is GC unfriendly because those types become
> non-trivially default constructible/copyable/destructible.
> One option would be to use trailing_wide_int for that instead, but
> as pointed out by Aldy, irange_storage which we already use under
> the hood for ipa_vr when type of parameter is integral or pointer
> already stores the mask/value pair because VRP now does the bit cp
> as well.
> So, this patch just uses m_vr to store both the value range and
> the bitmask.  There is still separate propagation of the
> ipcp_bits_lattice from propagation of the ipcp_vr_lattice, but
> when storing we merge the two into the same container.
>
> I've bootstrapped/regtested a slightly older version of this
> patch on x86_64-linux and i686-linux and that version regressed
> +FAIL: gcc.dg/ipa/propalign-3.c scan-ipa-dump-not cp "align:"
> +FAIL: gcc.dg/ipa/propalign-3.c scan-tree-dump optimized "fail_the_test"
> +FAIL: gcc.dg/ipa/propbits-1.c scan-ipa-dump cp "Adjusting mask for param
> 0 to 0x7"
> +FAIL: gcc.dg/ipa/propbits-2.c scan-ipa-dump cp "Adjusting mask for param
> 0 to 0xf"
> The last 2 were solely about the earlier patch not actually copying
> the if (dump_file) dumping of message that we set some mask for some
> parameter (since then added in the @@ -5985,6 +5741,77 @@ hunk).
> The first testcase is a test for -fno-ipa-bit-cp disabling bit cp
> for alignments.  For integral types I'm afraid it is a lost case
> when -fno-ipa-bit-cp -fipa-vrp is on when value ranges track bit cp
> as well, but for pointer alignments I've added
>   && opt_for_fn (cs->caller->decl, flag_ipa_bit_cp)
> and
>   && opt_for_fn (node->decl, flag_ipa_bit_cp)
> guards such that even just -fno-ipa-bit-cp disables it (alternatively
> we could just add -fno-ipa-vrp to propalign-3.c dg-options).
>
> Ok for trunk if this passes another bootstrap/regtest?
> Or defer until it is really needed (when the wide_int/widest_int
> changes are about to be committed)?
>

Up to the maintainers, but this looks like a nice cleanup that has merit on
its own. It's exactly what I had in mind when I worked on IPA earlier this
cycle.

Thanks.
Aldy


> 2023-10-05  Jakub Jelinek  <jakub@redhat.com>
>
>         * ipa-prop.h (ipa_bits): Remove.
>         (struct ipa_jump_func): Remove bits member.
>         (struct ipcp_transformation): Remove bits member, adjust
>         ctor and dtor.
>         (ipa_get_ipa_bits_for_value): Remove.
>         * ipa-prop.cc (struct ipa_bit_ggc_hash_traits): Remove.
>         (ipa_bits_hash_table): Remove.
>         (ipa_print_node_jump_functions_for_edge): Don't print bits.
>         (ipa_get_ipa_bits_for_value): Remove.
>         (ipa_set_jfunc_bits): Remove.
>         (ipa_compute_jump_functions_for_edge): For pointers query
>         pointer alignment before ipa_set_jfunc_vr and update_bitmask
>         in there.  For integral types, just rely on bitmask already
>         being handled in value ranges.
>         (ipa_check_create_edge_args): Don't create ipa_bits_hash_table.
>         (ipcp_transformation_initialize): Neither here.
>         (ipcp_transformation_t::duplicate): Don't copy bits vector.
>         (ipa_write_jump_function): Don't stream bits here.
>         (ipa_read_jump_function): Neither here.
>         (useful_ipcp_transformation_info_p): Don't test bits vec.
>         (write_ipcp_transformation_info): Don't stream bits here.
>         (read_ipcp_transformation_info): Neither here.
>         (ipcp_get_parm_bits): Get mask and value from m_vr rather
>         than bits.
>         (ipcp_update_bits): Remove.
>         (ipcp_update_vr): For pointers, set_ptr_info_alignment from
>         bitmask stored in value range.
>         (ipcp_transform_function): Don't test bits vector, don't call
>         ipcp_update_bits.
>         * ipa-cp.cc (propagate_bits_across_jump_function): Don't use
>         jfunc->bits, instead get mask and value from jfunc->m_vr.
>         (ipcp_store_bits_results): Remove.
>         (ipcp_store_vr_results): Incorporate parts of
>         ipcp_store_bits_results here, merge the bitmasks with value
>         range if both are supplied.
>         (ipcp_driver): Don't call ipcp_store_bits_results.
>         * ipa-sra.cc (zap_useless_ipcp_results): Remove *ts->bits
>         clearing.
>
> --- gcc/ipa-prop.h.jj   2023-10-05 11:32:40.172739988 +0200
> +++ gcc/ipa-prop.h      2023-10-05 11:36:45.405378086 +0200
> @@ -292,18 +292,6 @@ public:
>    array_slice<const ipa_argagg_value> m_elts;
>  };
>
> -/* Information about zero/non-zero bits.  */
> -class GTY(()) ipa_bits
> -{
> -public:
> -  /* The propagated value.  */
> -  widest_int value;
> -  /* Mask corresponding to the value.
> -     Similar to ccp_lattice_t, if xth bit of mask is 0,
> -     implies xth bit of value is constant.  */
> -  widest_int mask;
> -};
> -
>  /* Info about value ranges.  */
>
>  class GTY(()) ipa_vr
> @@ -342,11 +330,6 @@ struct GTY (()) ipa_jump_func
>       and its description.  */
>    struct ipa_agg_jump_function agg;
>
> -  /* Information about zero/non-zero bits.  The pointed to structure is
> shared
> -     betweed different jump functions.  Use ipa_set_jfunc_bits to set this
> -     field.  */
> -  class ipa_bits *bits;
> -
>    /* Information about value range, containing valid data only when
> vr_known is
>       true.  The pointed to structure is shared betweed different jump
>       functions.  Use ipa_set_jfunc_vr to set this field.  */
> @@ -940,15 +923,13 @@ struct GTY(()) ipcp_transformation
>  {
>    /* Default constructor.  */
>    ipcp_transformation ()
> -    : m_agg_values (nullptr), bits (nullptr), m_vr (nullptr),
> -    m_uid_to_idx (nullptr)
> +    : m_agg_values (nullptr), m_vr (nullptr), m_uid_to_idx (nullptr)
>    { }
>
>    /* Default destructor.  */
>    ~ipcp_transformation ()
>    {
>      vec_free (m_agg_values);
> -    vec_free (bits);
>      vec_free (m_vr);
>    }
>
> @@ -968,8 +949,6 @@ struct GTY(()) ipcp_transformation
>
>    /* Known aggregate values.  */
>    vec<ipa_argagg_value, va_gc>  *m_agg_values;
> -  /* Known bits information.  */
> -  vec<ipa_bits *, va_gc> *bits;
>    /* Value range information.  */
>    vec<ipa_vr, va_gc> *m_vr;
>    /* If there are many parameters, this is a vector sorted by their
> DECL_UIDs
> @@ -1172,8 +1151,6 @@ tree ipa_get_indirect_edge_target (struc
>  struct cgraph_edge *ipa_make_edge_direct_to_target (struct cgraph_edge *,
> tree,
>                                                     bool speculative =
> false);
>  tree ipa_impossible_devirt_target (struct cgraph_edge *, tree);
> -ipa_bits *ipa_get_ipa_bits_for_value (const widest_int &value,
> -                                     const widest_int &mask);
>
>
>  /* Functions related to both.  */
> --- gcc/ipa-prop.cc.jj  2023-10-05 11:32:40.154740234 +0200
> +++ gcc/ipa-prop.cc     2023-10-05 14:06:13.742885839 +0200
> @@ -66,49 +66,6 @@ function_summary <ipcp_transformation *>
>  /* Edge summary for IPA-CP edge information.  */
>  ipa_edge_args_sum_t *ipa_edge_args_sum;
>
> -/* Traits for a hash table for reusing already existing ipa_bits. */
> -
> -struct ipa_bit_ggc_hash_traits : public ggc_cache_remove <ipa_bits *>
> -{
> -  typedef ipa_bits *value_type;
> -  typedef ipa_bits *compare_type;
> -  static hashval_t
> -  hash (const ipa_bits *p)
> -  {
> -    hashval_t t = (hashval_t) p->value.to_shwi ();
> -    return iterative_hash_host_wide_int (p->mask.to_shwi (), t);
> -  }
> -  static bool
> -  equal (const ipa_bits *a, const ipa_bits *b)
> -    {
> -      return a->value == b->value && a->mask == b->mask;
> -    }
> -  static const bool empty_zero_p = true;
> -  static void
> -  mark_empty (ipa_bits *&p)
> -    {
> -      p = NULL;
> -    }
> -  static bool
> -  is_empty (const ipa_bits *p)
> -    {
> -      return p == NULL;
> -    }
> -  static bool
> -  is_deleted (const ipa_bits *p)
> -    {
> -      return p == reinterpret_cast<const ipa_bits *> (1);
> -    }
> -  static void
> -  mark_deleted (ipa_bits *&p)
> -    {
> -      p = reinterpret_cast<ipa_bits *> (1);
> -    }
> -};
> -
> -/* Hash table for avoid repeated allocations of equal ipa_bits.  */
> -static GTY ((cache)) hash_table<ipa_bit_ggc_hash_traits>
> *ipa_bits_hash_table;
> -
>  /* Traits for a hash table for reusing ranges.  */
>
>  struct ipa_vr_ggc_hash_traits : public ggc_cache_remove <ipa_vr *>
> @@ -528,17 +485,6 @@ ipa_print_node_jump_functions_for_edge (
>           ctx->dump (dump_file);
>         }
>
> -      if (jump_func->bits)
> -       {
> -         fprintf (f, "         value: ");
> -         print_hex (jump_func->bits->value, f);
> -         fprintf (f, ", mask: ");
> -         print_hex (jump_func->bits->mask, f);
> -         fprintf (f, "\n");
> -       }
> -      else
> -       fprintf (f, "         Unknown bits\n");
> -
>        if (jump_func->m_vr)
>         {
>           jump_func->m_vr->dump (f);
> @@ -2267,39 +2213,6 @@ ipa_get_callee_param_type (struct cgraph
>    return NULL;
>  }
>
> -/* Return ipa_bits with VALUE and MASK values, which can be either a newly
> -   allocated structure or a previously existing one shared with other jump
> -   functions and/or transformation summaries.  */
> -
> -ipa_bits *
> -ipa_get_ipa_bits_for_value (const widest_int &value, const widest_int
> &mask)
> -{
> -  ipa_bits tmp;
> -  tmp.value = value;
> -  tmp.mask = mask;
> -
> -  ipa_bits **slot = ipa_bits_hash_table->find_slot (&tmp, INSERT);
> -  if (*slot)
> -    return *slot;
> -
> -  ipa_bits *res = ggc_alloc<ipa_bits> ();
> -  res->value = value;
> -  res->mask = mask;
> -  *slot = res;
> -
> -  return res;
> -}
> -
> -/* Assign to JF a pointer to ipa_bits structure with VALUE and MASK.  Use
> hash
> -   table in order to avoid creating multiple same ipa_bits structures.  */
> -
> -static void
> -ipa_set_jfunc_bits (ipa_jump_func *jf, const widest_int &value,
> -                   const widest_int &mask)
> -{
> -  jf->bits = ipa_get_ipa_bits_for_value (value, mask);
> -}
> -
>  /* Return a pointer to an ipa_vr just like TMP, but either find it in
>     ipa_vr_hash_table or allocate it in GC memory.  */
>
> @@ -2393,10 +2306,31 @@ ipa_compute_jump_functions_for_edge (str
>             addr_nonzero = true;
>
>           if (addr_nonzero)
> +           vr.set_nonzero (TREE_TYPE (arg));
> +
> +         unsigned HOST_WIDE_INT bitpos;
> +         unsigned align, prec = TYPE_PRECISION (TREE_TYPE (arg));
> +
> +         get_pointer_alignment_1 (arg, &align, &bitpos);
> +
> +         if (align > BITS_PER_UNIT
> +             && opt_for_fn (cs->caller->decl, flag_ipa_bit_cp))
>             {
> -             vr.set_nonzero (TREE_TYPE (arg));
> +             wide_int mask
> +               = wi::bit_and_not (wi::mask (prec, false, prec),
> +                                  wide_int::from (align / BITS_PER_UNIT -
> 1,
> +                                                  prec, UNSIGNED));
> +             wide_int value = wide_int::from (bitpos / BITS_PER_UNIT,
> prec,
> +                                              UNSIGNED);
> +             irange_bitmask bm (value, mask);
> +             if (!addr_nonzero)
> +               vr.set_varying (TREE_TYPE (arg));
> +             irange &r = as_a <irange> (vr);
> +             r.update_bitmask (bm);
>               ipa_set_jfunc_vr (jfunc, vr);
>             }
> +         else if (addr_nonzero)
> +           ipa_set_jfunc_vr (jfunc, vr);
>           else
>             gcc_assert (!jfunc->m_vr);
>         }
> @@ -2421,30 +2355,6 @@ ipa_compute_jump_functions_for_edge (str
>             gcc_assert (!jfunc->m_vr);
>         }
>
> -      if (INTEGRAL_TYPE_P (TREE_TYPE (arg)) && !vr.undefined_p ())
> -       {
> -         irange &r = as_a <irange> (vr);
> -         irange_bitmask bm = r.get_bitmask ();
> -         signop sign = TYPE_SIGN (TREE_TYPE (arg));
> -         ipa_set_jfunc_bits (jfunc,
> -                             widest_int::from (bm.value (), sign),
> -                             widest_int::from (bm.mask (), sign));
> -       }
> -      else if (POINTER_TYPE_P (TREE_TYPE (arg)))
> -       {
> -         unsigned HOST_WIDE_INT bitpos;
> -         unsigned align;
> -
> -         get_pointer_alignment_1 (arg, &align, &bitpos);
> -         widest_int mask = wi::bit_and_not
> -           (wi::mask<widest_int> (TYPE_PRECISION (TREE_TYPE (arg)),
> false),
> -            align / BITS_PER_UNIT - 1);
> -         widest_int value = bitpos / BITS_PER_UNIT;
> -         ipa_set_jfunc_bits (jfunc, value, mask);
> -       }
> -      else
> -       gcc_assert (!jfunc->bits);
> -
>        if (is_gimple_ip_invariant (arg)
>           || (VAR_P (arg)
>               && is_global_var (arg)
> @@ -4398,8 +4308,6 @@ ipa_check_create_edge_args (void)
>      ipa_edge_args_sum
>        = (new (ggc_alloc_no_dtor<ipa_edge_args_sum_t> ())
>          ipa_edge_args_sum_t (symtab, true));
> -  if (!ipa_bits_hash_table)
> -    ipa_bits_hash_table = hash_table<ipa_bit_ggc_hash_traits>::create_ggc
> (37);
>    if (!ipa_vr_hash_table)
>      ipa_vr_hash_table = hash_table<ipa_vr_ggc_hash_traits>::create_ggc
> (37);
>  }
> @@ -4432,8 +4340,6 @@ ipa_free_all_node_params (void)
>  void
>  ipcp_transformation_initialize (void)
>  {
> -  if (!ipa_bits_hash_table)
> -    ipa_bits_hash_table = hash_table<ipa_bit_ggc_hash_traits>::create_ggc
> (37);
>    if (!ipa_vr_hash_table)
>      ipa_vr_hash_table = hash_table<ipa_vr_ggc_hash_traits>::create_ggc
> (37);
>    if (ipcp_transformation_sum == NULL)
> @@ -4636,7 +4542,6 @@ ipcp_transformation_t::duplicate(cgraph_
>    if (dst->inlined_to)
>      return;
>    dst_trans->m_agg_values = vec_safe_copy (src_trans->m_agg_values);
> -  dst_trans->bits = vec_safe_copy (src_trans->bits);
>    dst_trans->m_vr = vec_safe_copy (src_trans->m_vr);
>  }
>
> @@ -4859,13 +4764,6 @@ ipa_write_jump_function (struct output_b
>      }
>
>    bp = bitpack_create (ob->main_stream);
> -  bp_pack_value (&bp, !!jump_func->bits, 1);
> -  streamer_write_bitpack (&bp);
> -  if (jump_func->bits)
> -    {
> -      streamer_write_widest_int (ob, jump_func->bits->value);
> -      streamer_write_widest_int (ob, jump_func->bits->mask);
> -    }
>    if (jump_func->m_vr)
>      jump_func->m_vr->streamer_write (ob);
>    else
> @@ -4992,18 +4890,6 @@ ipa_read_jump_function (class lto_input_
>          jump_func->agg.items->quick_push (item);
>      }
>
> -  struct bitpack_d bp = streamer_read_bitpack (ib);
> -  bool bits_known = bp_unpack_value (&bp, 1);
> -  if (bits_known)
> -    {
> -      widest_int value = streamer_read_widest_int (ib);
> -      widest_int mask = streamer_read_widest_int (ib);
> -      if (prevails)
> -       ipa_set_jfunc_bits (jump_func, value, mask);
> -    }
> -  else
> -    jump_func->bits = NULL;
> -
>    ipa_vr vr;
>    vr.streamer_read (ib, data_in);
>    if (vr.known_p ())
> @@ -5387,7 +5273,6 @@ useful_ipcp_transformation_info_p (ipcp_
>    if (!ts)
>      return false;
>    if (!vec_safe_is_empty (ts->m_agg_values)
> -      || !vec_safe_is_empty (ts->bits)
>        || !vec_safe_is_empty (ts->m_vr))
>      return true;
>    return false;
> @@ -5420,19 +5305,6 @@ write_ipcp_transformation_info (output_b
>    streamer_write_uhwi (ob, vec_safe_length (ts->m_vr));
>    for (const ipa_vr &parm_vr : ts->m_vr)
>      parm_vr.streamer_write (ob);
> -
> -  streamer_write_uhwi (ob, vec_safe_length (ts->bits));
> -  for (const ipa_bits *bits_jfunc : ts->bits)
> -    {
> -      struct bitpack_d bp = bitpack_create (ob->main_stream);
> -      bp_pack_value (&bp, !!bits_jfunc, 1);
> -      streamer_write_bitpack (&bp);
> -      if (bits_jfunc)
> -       {
> -         streamer_write_widest_int (ob, bits_jfunc->value);
> -         streamer_write_widest_int (ob, bits_jfunc->mask);
> -       }
> -    }
>  }
>
>  /* Stream in the aggregate value replacement chain for NODE from IB.  */
> @@ -5473,24 +5345,6 @@ read_ipcp_transformation_info (lto_input
>           parm_vr->streamer_read (ib, data_in);
>         }
>      }
> -  count = streamer_read_uhwi (ib);
> -  if (count > 0)
> -    {
> -      vec_safe_grow_cleared (ts->bits, count, true);
> -      for (i = 0; i < count; i++)
> -       {
> -         struct bitpack_d bp = streamer_read_bitpack (ib);
> -         bool known = bp_unpack_value (&bp, 1);
> -         if (known)
> -           {
> -             const widest_int value = streamer_read_widest_int (ib);
> -             const widest_int mask = streamer_read_widest_int (ib);
> -             ipa_bits *bits
> -               = ipa_get_ipa_bits_for_value (value, mask);
> -             (*ts->bits)[i] = bits;
> -           }
> -       }
> -    }
>  }
>
>  /* Write all aggregate replacement for nodes in set.  */
> @@ -5796,7 +5650,9 @@ ipcp_get_parm_bits (tree parm, tree *val
>  {
>    cgraph_node *cnode = cgraph_node::get (current_function_decl);
>    ipcp_transformation *ts = ipcp_get_transformation_summary (cnode);
> -  if (!ts || vec_safe_length (ts->bits) == 0)
> +  if (!ts
> +      || vec_safe_length (ts->m_vr) == 0
> +      || !irange::supports_p (TREE_TYPE (parm)))
>      return false;
>
>    int i = ts->get_param_index (current_function_decl, parm);
> @@ -5810,120 +5666,20 @@ ipcp_get_parm_bits (tree parm, tree *val
>         return false;
>      }
>
> -  vec<ipa_bits *, va_gc> &bits = *ts->bits;
> -  if (!bits[i])
> +  vec<ipa_vr, va_gc> &vr = *ts->m_vr;
> +  if (!vr[i].known_p ())
>      return false;
> -  *mask = bits[i]->mask;
> -  *value = wide_int_to_tree (TREE_TYPE (parm), bits[i]->value);
> +  Value_Range tmp;
> +  vr[i].get_vrange (tmp);
> +  if (tmp.undefined_p () || tmp.varying_p ())
> +    return false;
> +  irange &r = as_a <irange> (tmp);
> +  irange_bitmask bm = r.get_bitmask ();
> +  *mask = widest_int::from (bm.mask (), TYPE_SIGN (TREE_TYPE (parm)));
> +  *value = wide_int_to_tree (TREE_TYPE (parm), bm.value ());
>    return true;
>  }
>
> -/* Update bits info of formal parameters of NODE as described in TS.  */
> -
> -static void
> -ipcp_update_bits (struct cgraph_node *node, ipcp_transformation *ts)
> -{
> -  if (vec_safe_is_empty (ts->bits))
> -    return;
> -  vec<ipa_bits *, va_gc> &bits = *ts->bits;
> -  unsigned count = bits.length ();
> -  if (!count)
> -    return;
> -
> -  auto_vec<int, 16> new_indices;
> -  bool need_remapping = false;
> -  clone_info *cinfo = clone_info::get (node);
> -  if (cinfo && cinfo->param_adjustments)
> -    {
> -      cinfo->param_adjustments->get_updated_indices (&new_indices);
> -      need_remapping = true;
> -    }
> -  auto_vec <tree, 16> parm_decls;
> -  push_function_arg_decls (&parm_decls, node->decl);
> -
> -  for (unsigned i = 0; i < count; ++i)
> -    {
> -      tree parm;
> -      if (need_remapping)
> -       {
> -         if (i >= new_indices.length ())
> -           continue;
> -         int idx = new_indices[i];
> -         if (idx < 0)
> -           continue;
> -         parm = parm_decls[idx];
> -       }
> -      else
> -       parm = parm_decls[i];
> -      gcc_checking_assert (parm);
> -
> -
> -      if (!bits[i]
> -         || !(INTEGRAL_TYPE_P (TREE_TYPE (parm))
> -              || POINTER_TYPE_P (TREE_TYPE (parm)))
> -         || !is_gimple_reg (parm))
> -       continue;
> -
> -      tree ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->decl),
> parm);
> -      if (!ddef)
> -       continue;
> -
> -      if (dump_file)
> -       {
> -         fprintf (dump_file, "Adjusting mask for param %u to ", i);
> -         print_hex (bits[i]->mask, dump_file);
> -         fprintf (dump_file, "\n");
> -       }
> -
> -      if (INTEGRAL_TYPE_P (TREE_TYPE (ddef)))
> -       {
> -         unsigned prec = TYPE_PRECISION (TREE_TYPE (ddef));
> -         signop sgn = TYPE_SIGN (TREE_TYPE (ddef));
> -         wide_int mask = wide_int::from (bits[i]->mask, prec, UNSIGNED);
> -         wide_int value = wide_int::from (bits[i]->value, prec, sgn);
> -         set_bitmask (ddef, value, mask);
> -       }
> -      else
> -       {
> -         unsigned tem = bits[i]->mask.to_uhwi ();
> -         unsigned HOST_WIDE_INT bitpos = bits[i]->value.to_uhwi ();
> -         unsigned align = tem & -tem;
> -         unsigned misalign = bitpos & (align - 1);
> -
> -         if (align > 1)
> -           {
> -             if (dump_file)
> -               fprintf (dump_file, "Adjusting align: %u, misalign: %u\n",
> align, misalign);
> -
> -             unsigned old_align, old_misalign;
> -             struct ptr_info_def *pi = get_ptr_info (ddef);
> -             bool old_known = get_ptr_info_alignment (pi, &old_align,
> &old_misalign);
> -
> -             if (old_known
> -                 && old_align > align)
> -               {
> -                 if (dump_file)
> -                   {
> -                     fprintf (dump_file, "But alignment was already
> %u.\n", old_align);
> -                     if ((old_misalign & (align - 1)) != misalign)
> -                       fprintf (dump_file, "old_misalign (%u) and
> misalign (%u) mismatch\n",
> -                                old_misalign, misalign);
> -                   }
> -                 continue;
> -               }
> -
> -             if (old_known
> -                 && ((misalign & (old_align - 1)) != old_misalign)
> -                 && dump_file)
> -               fprintf (dump_file, "old_misalign (%u) and misalign (%u)
> mismatch\n",
> -                        old_misalign, misalign);
> -
> -             set_ptr_info_alignment (pi, align, misalign);
> -           }
> -       }
> -    }
> -}
> -
>  /* Update value range of formal parameters of NODE as described in TS.  */
>
>  static void
> @@ -5985,6 +5741,77 @@ ipcp_update_vr (struct cgraph_node *node
>                   fprintf (dump_file, "]\n");
>                 }
>               set_range_info (ddef, tmp);
> +
> +             if (POINTER_TYPE_P (TREE_TYPE (parm))
> +                 && opt_for_fn (node->decl, flag_ipa_bit_cp))
> +               {
> +                 irange &r = as_a<irange> (tmp);
> +                 irange_bitmask bm = r.get_bitmask ();
> +                 unsigned tem = bm.mask ().to_uhwi ();
> +                 unsigned HOST_WIDE_INT bitpos = bm.value ().to_uhwi ();
> +                 unsigned align = tem & -tem;
> +                 unsigned misalign = bitpos & (align - 1);
> +
> +                 if (align > 1)
> +                   {
> +                     if (dump_file)
> +                       {
> +                         fprintf (dump_file,
> +                                  "Adjusting mask for param %u to ", i);
> +                         print_hex (bm.mask (), dump_file);
> +                         fprintf (dump_file, "\n");
> +                       }
> +
> +                     if (dump_file)
> +                       fprintf (dump_file,
> +                                "Adjusting align: %u, misalign: %u\n",
> +                                align, misalign);
> +
> +                     unsigned old_align, old_misalign;
> +                     struct ptr_info_def *pi = get_ptr_info (ddef);
> +                     bool old_known = get_ptr_info_alignment (pi,
> &old_align,
> +
> &old_misalign);
> +
> +                     if (old_known && old_align > align)
> +                       {
> +                         if (dump_file)
> +                           {
> +                             fprintf (dump_file,
> +                                      "But alignment was already %u.\n",
> +                                      old_align);
> +                             if ((old_misalign & (align - 1)) != misalign)
> +                               fprintf (dump_file,
> +                                        "old_misalign (%u) and misalign "
> +                                        "(%u) mismatch\n",
> +                                        old_misalign, misalign);
> +                           }
> +                         continue;
> +                       }
> +
> +                     if (dump_file
> +                         && old_known
> +                         && ((misalign & (old_align - 1)) !=
> old_misalign))
> +                       fprintf (dump_file,
> +                                "old_misalign (%u) and misalign (%u) "
> +                                "mismatch\n",
> +                                old_misalign, misalign);
> +
> +                     set_ptr_info_alignment (pi, align, misalign);
> +                   }
> +               }
> +             else if (dump_file && INTEGRAL_TYPE_P (TREE_TYPE (parm)))
> +               {
> +                 irange &r = as_a<irange> (tmp);
> +                 irange_bitmask bm = r.get_bitmask ();
> +                 unsigned prec = TYPE_PRECISION (TREE_TYPE (parm));
> +                 if (wi::ne_p (bm.mask (), wi::shwi (-1, prec)))
> +                   {
> +                     fprintf (dump_file,
> +                              "Adjusting mask for param %u to ", i);
> +                     print_hex (bm.mask (), dump_file);
> +                     fprintf (dump_file, "\n");
> +                   }
> +               }
>             }
>         }
>      }
> @@ -6008,12 +5835,10 @@ ipcp_transform_function (struct cgraph_n
>    ipcp_transformation *ts = ipcp_get_transformation_summary (node);
>    if (!ts
>        || (vec_safe_is_empty (ts->m_agg_values)
> -         && vec_safe_is_empty (ts->bits)
>           && vec_safe_is_empty (ts->m_vr)))
>      return 0;
>
>    ts->maybe_create_parm_idx_map (cfun->decl);
> -  ipcp_update_bits (node, ts);
>    ipcp_update_vr (node, ts);
>    if (vec_safe_is_empty (ts->m_agg_values))
>        return 0;
> --- gcc/ipa-cp.cc.jj    2023-10-05 11:32:39.828744703 +0200
> +++ gcc/ipa-cp.cc       2023-10-05 11:36:45.408378045 +0200
> @@ -2749,11 +2749,22 @@ propagate_bits_across_jump_function (cgr
>         }
>      }
>
> -  if (jfunc->bits)
> -    return dest_lattice->meet_with (jfunc->bits->value, jfunc->bits->mask,
> -                                   precision);
> -  else
> -    return dest_lattice->set_to_bottom ();
> +  Value_Range vr (parm_type);
> +  if (jfunc->m_vr)
> +    {
> +      jfunc->m_vr->get_vrange (vr);
> +      if (!vr.undefined_p () && !vr.varying_p ())
> +       {
> +         irange &r = as_a <irange> (vr);
> +         irange_bitmask bm = r.get_bitmask ();
> +         widest_int mask
> +           = widest_int::from (bm.mask (), TYPE_SIGN (parm_type));
> +         widest_int value
> +           = widest_int::from (bm.value (), TYPE_SIGN (parm_type));
> +         return dest_lattice->meet_with (value, mask, precision);
> +       }
> +    }
> +  return dest_lattice->set_to_bottom ();
>  }
>
>  /* Propagate value range across jump function JFUNC that is associated
> with
> @@ -6521,89 +6532,8 @@ ipcp_decision_stage (class ipa_topo_info
>      }
>  }
>
> -/* Look up all the bits information that we have discovered and copy it
> over
> -   to the transformation summary.  */
> -
> -static void
> -ipcp_store_bits_results (void)
> -{
> -  cgraph_node *node;
> -
> -  FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
> -    {
> -      ipa_node_params *info = ipa_node_params_sum->get (node);
> -      bool dumped_sth = false;
> -      bool found_useful_result = false;
> -
> -      if (!opt_for_fn (node->decl, flag_ipa_bit_cp) || !info)
> -       {
> -         if (dump_file)
> -           fprintf (dump_file, "Not considering %s for ipa bitwise
> propagation "
> -                               "; -fipa-bit-cp: disabled.\n",
> -                               node->dump_name ());
> -         continue;
> -       }
> -
> -      if (info->ipcp_orig_node)
> -       info = ipa_node_params_sum->get (info->ipcp_orig_node);
> -      if (!info->lattices)
> -       /* Newly expanded artificial thunks do not have lattices.  */
> -       continue;
> -
> -      unsigned count = ipa_get_param_count (info);
> -      for (unsigned i = 0; i < count; i++)
> -       {
> -         ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
> -         if (plats->bits_lattice.constant_p ())
> -           {
> -             found_useful_result = true;
> -             break;
> -           }
> -       }
> -
> -      if (!found_useful_result)
> -       continue;
> -
> -      ipcp_transformation_initialize ();
> -      ipcp_transformation *ts = ipcp_transformation_sum->get_create
> (node);
> -      vec_safe_reserve_exact (ts->bits, count);
> -
> -      for (unsigned i = 0; i < count; i++)
> -       {
> -         ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
> -         ipa_bits *jfbits;
> -
> -         if (plats->bits_lattice.constant_p ())
> -           {
> -             jfbits
> -               = ipa_get_ipa_bits_for_value
> (plats->bits_lattice.get_value (),
> -                                             plats->bits_lattice.get_mask
> ());
> -             if (!dbg_cnt (ipa_cp_bits))
> -               jfbits = NULL;
> -           }
> -         else
> -           jfbits = NULL;
> -
> -         ts->bits->quick_push (jfbits);
> -         if (!dump_file || !jfbits)
> -           continue;
> -         if (!dumped_sth)
> -           {
> -             fprintf (dump_file, "Propagated bits info for function
> %s:\n",
> -                      node->dump_name ());
> -             dumped_sth = true;
> -           }
> -         fprintf (dump_file, " param %i: value = ", i);
> -         print_hex (jfbits->value, dump_file);
> -         fprintf (dump_file, ", mask = ");
> -         print_hex (jfbits->mask, dump_file);
> -         fprintf (dump_file, "\n");
> -       }
> -    }
> -}
> -
> -/* Look up all VR information that we have discovered and copy it over
> -   to the transformation summary.  */
> +/* Look up all VR and bits information that we have discovered and copy it
> +   over to the transformation summary.  */
>
>  static void
>  ipcp_store_vr_results (void)
> @@ -6613,7 +6543,10 @@ ipcp_store_vr_results (void)
>    FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
>      {
>        ipa_node_params *info = ipa_node_params_sum->get (node);
> +      bool dumped_sth = false;
>        bool found_useful_result = false;
> +      bool do_vr = true;
> +      bool do_bits = true;
>
>        if (!info || !opt_for_fn (node->decl, flag_ipa_vrp))
>         {
> @@ -6621,8 +6554,18 @@ ipcp_store_vr_results (void)
>             fprintf (dump_file, "Not considering %s for VR discovery "
>                      "and propagate; -fipa-ipa-vrp: disabled.\n",
>                      node->dump_name ());
> -         continue;
> +         do_vr = false;
> +       }
> +      if (!info || !opt_for_fn (node->decl, flag_ipa_bit_cp))
> +       {
> +         if (dump_file)
> +           fprintf (dump_file, "Not considering %s for ipa bitwise "
> +                               "propagation ; -fipa-bit-cp: disabled.\n",
> +                               node->dump_name ());
> +         do_bits = false;
>         }
> +      if (!do_bits && !do_vr)
> +       continue;
>
>        if (info->ipcp_orig_node)
>         info = ipa_node_params_sum->get (info->ipcp_orig_node);
> @@ -6634,12 +6577,18 @@ ipcp_store_vr_results (void)
>        for (unsigned i = 0; i < count; i++)
>         {
>           ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
> -         if (!plats->m_value_range.bottom_p ()
> +         if (do_vr
> +             && !plats->m_value_range.bottom_p ()
>               && !plats->m_value_range.top_p ())
>             {
>               found_useful_result = true;
>               break;
>             }
> +         if (do_bits && plats->bits_lattice.constant_p ())
> +           {
> +             found_useful_result = true;
> +             break;
> +           }
>         }
>        if (!found_useful_result)
>         continue;
> @@ -6651,12 +6600,53 @@ ipcp_store_vr_results (void)
>        for (unsigned i = 0; i < count; i++)
>         {
>           ipcp_param_lattices *plats = ipa_get_parm_lattices (info, i);
> +         ipcp_bits_lattice *bits = NULL;
> +
> +         if (do_bits
> +             && plats->bits_lattice.constant_p ()
> +             && dbg_cnt (ipa_cp_bits))
> +           bits = &plats->bits_lattice;
>
> -         if (!plats->m_value_range.bottom_p ()
> +         if (do_vr
> +             && !plats->m_value_range.bottom_p ()
>               && !plats->m_value_range.top_p ()
>               && dbg_cnt (ipa_cp_vr))
>             {
> -             ipa_vr vr (plats->m_value_range.m_vr);
> +             if (bits)
> +               {
> +                 Value_Range tmp = plats->m_value_range.m_vr;
> +                 tree type = ipa_get_type (info, i);
> +                 irange &r = as_a<irange> (tmp);
> +                 irange_bitmask bm (wide_int::from (bits->get_value (),
> +                                                    TYPE_PRECISION (type),
> +                                                    TYPE_SIGN (type)),
> +                                    wide_int::from (bits->get_mask (),
> +                                                    TYPE_PRECISION (type),
> +                                                    TYPE_SIGN (type)));
> +                 r.update_bitmask (bm);
> +                 ipa_vr vr (tmp);
> +                 ts->m_vr->quick_push (vr);
> +               }
> +             else
> +               {
> +                 ipa_vr vr (plats->m_value_range.m_vr);
> +                 ts->m_vr->quick_push (vr);
> +               }
> +           }
> +         else if (bits)
> +           {
> +             tree type = ipa_get_type (info, i);
> +             Value_Range tmp;
> +             tmp.set_varying (type);
> +             irange &r = as_a<irange> (tmp);
> +             irange_bitmask bm (wide_int::from (bits->get_value (),
> +                                                TYPE_PRECISION (type),
> +                                                TYPE_SIGN (type)),
> +                                wide_int::from (bits->get_mask (),
> +                                                TYPE_PRECISION (type),
> +                                                TYPE_SIGN (type)));
> +             r.update_bitmask (bm);
> +             ipa_vr vr (tmp);
>               ts->m_vr->quick_push (vr);
>             }
>           else
> @@ -6664,6 +6654,21 @@ ipcp_store_vr_results (void)
>               ipa_vr vr;
>               ts->m_vr->quick_push (vr);
>             }
> +
> +         if (!dump_file || !bits)
> +           continue;
> +
> +         if (!dumped_sth)
> +           {
> +             fprintf (dump_file, "Propagated bits info for function
> %s:\n",
> +                      node->dump_name ());
> +             dumped_sth = true;
> +           }
> +         fprintf (dump_file, " param %i: value = ", i);
> +         print_hex (bits->get_value (), dump_file);
> +         fprintf (dump_file, ", mask = ");
> +         print_hex (bits->get_mask (), dump_file);
> +         fprintf (dump_file, "\n");
>         }
>      }
>  }
> @@ -6696,9 +6701,7 @@ ipcp_driver (void)
>    ipcp_propagate_stage (&topo);
>    /* Decide what constant propagation and cloning should be performed.  */
>    ipcp_decision_stage (&topo);
> -  /* Store results of bits propagation.  */
> -  ipcp_store_bits_results ();
> -  /* Store results of value range propagation.  */
> +  /* Store results of value range and bits propagation.  */
>    ipcp_store_vr_results ();
>
>    /* Free all IPCP structures.  */
> --- gcc/ipa-sra.cc.jj   2023-10-05 11:32:40.233739151 +0200
> +++ gcc/ipa-sra.cc      2023-10-05 11:36:45.408378045 +0200
> @@ -4134,22 +4134,8 @@ zap_useless_ipcp_results (const isra_fun
>    else if (removed_item)
>      ts->m_agg_values->truncate (dst_index);
>
> -  bool useful_bits = false;
> -  unsigned count = vec_safe_length (ts->bits);
> -  for (unsigned i = 0; i < count; i++)
> -    if ((*ts->bits)[i])
> -    {
> -      const isra_param_desc *desc = &(*ifs->m_parameters)[i];
> -      if (desc->locally_unused)
> -       (*ts->bits)[i] = NULL;
> -      else
> -       useful_bits = true;
> -    }
> -  if (!useful_bits)
> -    ts->bits = NULL;
> -
>    bool useful_vr = false;
> -  count = vec_safe_length (ts->m_vr);
> +  unsigned count = vec_safe_length (ts->m_vr);
>    for (unsigned i = 0; i < count; i++)
>      if ((*ts->m_vr)[i].known_p ())
>        {
>
>         Jakub
>
>