ping

> -----Original Message-----
> From: Tamar Christina <tamar.christ...@arm.com>
> Sent: Tuesday, November 5, 2024 9:04 AM
> To: gcc-patches@gcc.gnu.org
> Cc: nd <n...@arm.com>; rguent...@suse.de; j...@ventanamicro.com
> Subject: RE: [PATCH 1/2]middle-end: refactor type to be explicit in
> operand_equal_p [PR114932]
> 
> ping
> 
> > -----Original Message-----
> > From: Tamar Christina <tamar.christ...@arm.com>
> > Sent: Monday, October 14, 2024 4:08 PM
> > To: Tamar Christina <tamar.christ...@arm.com>; gcc-patches@gcc.gnu.org
> > Cc: nd <n...@arm.com>; rguent...@suse.de; j...@ventanamicro.com
> > Subject: RE: [PATCH 1/2]middle-end: refactor type to be explicit in
> > operand_equal_p [PR114932]
> >
> > ping
> >
> > > -----Original Message-----
> > > From: Tamar Christina <tamar.christ...@arm.com>
> > > Sent: Monday, September 23, 2024 8:41 AM
> > > To: gcc-patches@gcc.gnu.org
> > > Cc: nd <n...@arm.com>; rguent...@suse.de; j...@ventanamicro.com
> > > Subject: RE: [PATCH 1/2]middle-end: refactor type to be explicit in
> > > operand_equal_p [PR114932]
> > >
> > > ping
> > >
> > > > -----Original Message-----
> > > > From: Tamar Christina
> > > > Sent: Tuesday, September 10, 2024 8:57 PM
> > > > To: Tamar Christina <tamar.christ...@arm.com>; gcc-patches@gcc.gnu.org
> > > > Cc: nd <n...@arm.com>; rguent...@suse.de; j...@ventanamicro.com
> > > > Subject: RE: [PATCH 1/2]middle-end: refactor type to be explicit in
> > > > operand_equal_p [PR114932]
> > > >
> > > > ping
> > > >
> > > > > -----Original Message-----
> > > > > From: Tamar Christina <tamar.christ...@arm.com>
> > > > > Sent: Tuesday, August 20, 2024 2:06 PM
> > > > > To: gcc-patches@gcc.gnu.org
> > > > > Cc: nd <n...@arm.com>; rguent...@suse.de; j...@ventanamicro.com
> > > > > Subject: [PATCH 1/2]middle-end: refactor type to be explicit in
> > > operand_equal_p
> > > > > [PR114932]
> > > > >
> > > > > Hi All,
> > > > >
> > > > > This is a refactoring with no expected behavioral change.
> > > > > The goal with this is to make the type of the expressions being used 
> > > > > explicit.
> > > > >
> > > > > I did not change all the recursive calls to operand_equal_p () to 
> > > > > recurse
> > > > > directly to the new function but instead this goes through the top 
> > > > > level call
> > > > > which re-extracts the types.
> > > > >
> > > > > This was done because in most of the cases where we recurse type == 
> > > > > arg.
> > > > > The second patch makes use of this new flexibility to implement an 
> > > > > overload
> > > > > of operand_equal_p which checks for equality under two's complement.
> > > > >
> > > > > Bootstrapped Regtested on aarch64-none-linux-gnu,
> > > > > arm-none-linux-gnueabihf, x86_64-pc-linux-gnu
> > > > > -m32, -m64 and no issues.
> > > > >
> > > > > Ok for master?
> > > > >
> > > > > Thanks,
> > > > > Tamar
> > > > >
> > > > > gcc/ChangeLog:
> > > > >
> > > > >       PR tree-optimization/114932
> > > > >       * fold-const.cc (operand_compare::operand_equal_p): Split into 
> > > > > one that
> > > > >       takes explicit type parameters and use that in public one.
> > > > >       * fold-const.h (class operand_compare): Add operand_equal_p 
> > > > > private
> > > > >       overload.
> > > > >
> > > > > ---
> > > > > diff --git a/gcc/fold-const.h b/gcc/fold-const.h
> > > > > index
> > > > >
> > > >
> > >
> >
> b82ef137e2f2096f86c20df3c7749747e604177e..878545b1148b839e8a8e866f
> > > > > 38e31161f0d116c8 100644
> > > > > --- a/gcc/fold-const.h
> > > > > +++ b/gcc/fold-const.h
> > > > > @@ -273,6 +273,12 @@ protected:
> > > > >       true is returned.  Then RET is set to corresponding comparsion 
> > > > > result.  */
> > > > >    bool verify_hash_value (const_tree arg0, const_tree arg1, unsigned 
> > > > > int
> > flags,
> > > > >                         bool *ret);
> > > > > +
> > > > > +private:
> > > > > +  /* Return true if two operands are equal.  The flags fields can be 
> > > > > used
> > > > > +     to specify OEP flags described in tree-core.h.  */
> > > > > +  bool operand_equal_p (tree, const_tree, tree, const_tree,
> > > > > +                     unsigned int flags);
> > > > >  };
> > > > >
> > > > >  #endif // GCC_FOLD_CONST_H
> > > > > diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc
> > > > > index
> > > > >
> > > >
> > >
> >
> 8908e7381e72cbbf4a8fd96f18cbf4436aba8441..71e82b1d76d4106c7c23c54af
> > > > > 8b35905a1af9f1c 100644
> > > > > --- a/gcc/fold-const.cc
> > > > > +++ b/gcc/fold-const.cc
> > > > > @@ -3156,6 +3156,17 @@ combine_comparisons (location_t loc,
> > > > >  bool
> > > > >  operand_compare::operand_equal_p (const_tree arg0, const_tree arg1,
> > > > >                                 unsigned int flags)
> > > > > +{
> > > > > +  return operand_equal_p (TREE_TYPE (arg0), arg0, TREE_TYPE (arg1),
> arg1,
> > > > > flags);
> > > > > +}
> > > > > +
> > > > > +/* The same as operand_equal_p however the type of ARG0 and ARG1 are
> > > > > assumed to be
> > > > > +   the TYPE0 and TYPE1 respectively.  */
> > > > > +
> > > > > +bool
> > > > > +operand_compare::operand_equal_p (tree type0, const_tree arg0,
> > > > > +                               tree type1, const_tree arg1,
> > > > > +                               unsigned int flags)
> > > > >  {
> > > > >    bool r;
> > > > >    if (verify_hash_value (arg0, arg1, flags, &r))
> > > > > @@ -3166,25 +3177,25 @@ operand_compare::operand_equal_p
> > > (const_tree
> > > > > arg0, const_tree arg1,
> > > > >
> > > > >    /* If either is ERROR_MARK, they aren't equal.  */
> > > > >    if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) ==
> > > ERROR_MARK
> > > > > -      || TREE_TYPE (arg0) == error_mark_node
> > > > > -      || TREE_TYPE (arg1) == error_mark_node)
> > > > > +      || type0 == error_mark_node
> > > > > +      || type1 == error_mark_node)
> > > > >      return false;
> > > > >
> > > > >    /* Similar, if either does not have a type (like a template id),
> > > > >       they aren't equal.  */
> > > > > -  if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
> > > > > +  if (!type0 || !type1)
> > > > >      return false;
> > > > >
> > > > >    /* Bitwise identity makes no sense if the values have different 
> > > > > layouts.  */
> > > > >    if ((flags & OEP_BITWISE)
> > > > > -      && !tree_nop_conversion_p (TREE_TYPE (arg0), TREE_TYPE (arg1)))
> > > > > +      && !tree_nop_conversion_p (type0, type1))
> > > > >      return false;
> > > > >
> > > > >    /* We cannot consider pointers to different address space equal.  
> > > > > */
> > > > > -  if (POINTER_TYPE_P (TREE_TYPE (arg0))
> > > > > -      && POINTER_TYPE_P (TREE_TYPE (arg1))
> > > > > -      && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
> > > > > -       != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
> > > > > +  if (POINTER_TYPE_P (type0)
> > > > > +      && POINTER_TYPE_P (type1)
> > > > > +      && (TYPE_ADDR_SPACE (TREE_TYPE (type0))
> > > > > +       != TYPE_ADDR_SPACE (TREE_TYPE (type1))))
> > > > >      return false;
> > > > >
> > > > >    /* Check equality of integer constants before bailing out due to
> > > > > @@ -3211,12 +3222,15 @@ operand_compare::operand_equal_p
> > > (const_tree
> > > > > arg0, const_tree arg1,
> > > > >
> > > > >        /* If both types don't have the same precision, then it is not 
> > > > > safe
> > > > >        to strip NOPs.  */
> > > > > -      if (element_precision (TREE_TYPE (arg0))
> > > > > -       != element_precision (TREE_TYPE (arg1)))
> > > > > +      if (element_precision (type0)
> > > > > +       != element_precision (type1))
> > > > >       return false;
> > > > >
> > > > >        STRIP_NOPS (arg0);
> > > > >        STRIP_NOPS (arg1);
> > > > > +
> > > > > +      type0 = TREE_TYPE (arg0);
> > > > > +      type1 = TREE_TYPE (arg1);
> > > > >      }
> > > > >  #if 0
> > > > >    /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. 
> > > > > Enable
> > the
> > > > > @@ -3275,9 +3289,9 @@ operand_compare::operand_equal_p
> (const_tree
> > > > arg0,
> > > > > const_tree arg1,
> > > > >
> > > > >    /* When not checking adddresses, this is needed for conversions 
> > > > > and for
> > > > >       COMPONENT_REF.  Might as well play it safe and always test 
> > > > > this.  */
> > > > > -  if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
> > > > > -      || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
> > > > > -      || (TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE 
> > > > > (arg1))
> > > > > +  if (TREE_CODE (type0) == ERROR_MARK
> > > > > +      || TREE_CODE (type1) == ERROR_MARK
> > > > > +      || (TYPE_MODE (type0) != TYPE_MODE (type1)
> > > > >         && !(flags & OEP_ADDRESS_OF)))
> > > > >      return false;
> > > > >
> > > > > @@ -3364,8 +3378,8 @@ operand_compare::operand_equal_p
> (const_tree
> > > > arg0,
> > > > > const_tree arg1,
> > > > >           return true;
> > > > >
> > > > >         /* See sem_variable::equals in ipa-icf for a similar 
> > > > > approach.  */
> > > > > -       tree typ0 = TREE_TYPE (arg0);
> > > > > -       tree typ1 = TREE_TYPE (arg1);
> > > > > +       tree typ0 = type0;
> > > > > +       tree typ1 = type1;
> > > > >
> > > > >         if (TREE_CODE (typ0) != TREE_CODE (typ1))
> > > > >           return false;
> > > > > @@ -3444,8 +3458,8 @@ operand_compare::operand_equal_p
> (const_tree
> > > > arg0,
> > > > > const_tree arg1,
> > > > >          {
> > > > >       CASE_CONVERT:
> > > > >          case FIX_TRUNC_EXPR:
> > > > > -       if (TYPE_UNSIGNED (TREE_TYPE (arg0))
> > > > > -           != TYPE_UNSIGNED (TREE_TYPE (arg1)))
> > > > > +       if (TYPE_UNSIGNED (type0)
> > > > > +           != TYPE_UNSIGNED (type1))
> > > > >           return false;
> > > > >         break;
> > > > >       default:
> > > > > @@ -3481,12 +3495,12 @@ operand_compare::operand_equal_p
> > > (const_tree
> > > > > arg0, const_tree arg1,
> > > > >       case INDIRECT_REF:
> > > > >         if (!(flags & OEP_ADDRESS_OF))
> > > > >           {
> > > > > -           if (TYPE_ALIGN (TREE_TYPE (arg0))
> > > > > -               != TYPE_ALIGN (TREE_TYPE (arg1)))
> > > > > +           if (TYPE_ALIGN (type0)
> > > > > +               != TYPE_ALIGN (type1))
> > > > >               return false;
> > > > >             /* Verify that the access types are compatible.  */
> > > > > -           if (TYPE_MAIN_VARIANT (TREE_TYPE (arg0))
> > > > > -               != TYPE_MAIN_VARIANT (TREE_TYPE (arg1)))
> > > > > +           if (TYPE_MAIN_VARIANT (type0)
> > > > > +               != TYPE_MAIN_VARIANT (type1))
> > > > >               return false;
> > > > >           }
> > > > >         flags &= ~OEP_ADDRESS_OF;
> > > > > @@ -3494,8 +3508,8 @@ operand_compare::operand_equal_p
> (const_tree
> > > > arg0,
> > > > > const_tree arg1,
> > > > >
> > > > >       case IMAGPART_EXPR:
> > > > >         /* Require the same offset.  */
> > > > > -       if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
> > > > > -                             TYPE_SIZE (TREE_TYPE (arg1)),
> > > > > +       if (!operand_equal_p (TYPE_SIZE (type0),
> > > > > +                             TYPE_SIZE (type1),
> > > > >                               flags & ~OEP_ADDRESS_OF))
> > > > >           return false;
> > > > >
> > > > > @@ -3509,15 +3523,15 @@ operand_compare::operand_equal_p
> > > (const_tree
> > > > > arg0, const_tree arg1,
> > > > >         if (!(flags & OEP_ADDRESS_OF))
> > > > >           {
> > > > >             /* Require equal access sizes */
> > > > > -           if (TYPE_SIZE (TREE_TYPE (arg0)) != TYPE_SIZE (TREE_TYPE 
> > > > > (arg1))
> > > > > -               && (!TYPE_SIZE (TREE_TYPE (arg0))
> > > > > -                   || !TYPE_SIZE (TREE_TYPE (arg1))
> > > > > -                   || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
> > > > > -                                        TYPE_SIZE (TREE_TYPE (arg1)),
> > > > > +           if (TYPE_SIZE (type0) != TYPE_SIZE (type1)
> > > > > +               && (!TYPE_SIZE (type0)
> > > > > +                   || !TYPE_SIZE (type1)
> > > > > +                   || !operand_equal_p (TYPE_SIZE (type0),
> > > > > +                                        TYPE_SIZE (type1),
> > > > >                                          flags)))
> > > > >               return false;
> > > > >             /* Verify that access happens in similar types.  */
> > > > > -           if (!types_compatible_p (TREE_TYPE (arg0), TREE_TYPE 
> > > > > (arg1)))
> > > > > +           if (!types_compatible_p (type0, type1))
> > > > >               return false;
> > > > >             /* Verify that accesses are TBAA compatible.  */
> > > > >             if (!alias_ptr_types_compatible_p
> > > > > @@ -3529,8 +3543,8 @@ operand_compare::operand_equal_p
> (const_tree
> > > > arg0,
> > > > > const_tree arg1,
> > > > >                     != MR_DEPENDENCE_BASE (arg1)))
> > > > >               return false;
> > > > >            /* Verify that alignment is compatible.  */
> > > > > -          if (TYPE_ALIGN (TREE_TYPE (arg0))
> > > > > -              != TYPE_ALIGN (TREE_TYPE (arg1)))
> > > > > +          if (TYPE_ALIGN (type0)
> > > > > +              != TYPE_ALIGN (type1))
> > > > >               return false;
> > > > >           }
> > > > >         flags &= ~OEP_ADDRESS_OF;
> > > > > @@ -3802,16 +3816,16 @@ operand_compare::operand_equal_p
> > > (const_tree
> > > > > arg0, const_tree arg1,
> > > > >            indexed in increasing order and form an initial sequence.
> > > > >
> > > > >            We make no effort to compare nonconstant ones in GENERIC.  
> > > > > */
> > > > > -       if (!VECTOR_TYPE_P (TREE_TYPE (arg0))
> > > > > -           || !VECTOR_TYPE_P (TREE_TYPE (arg1)))
> > > > > +       if (!VECTOR_TYPE_P (type0)
> > > > > +           || !VECTOR_TYPE_P (type1))
> > > > >           return false;
> > > > >
> > > > >         /* Be sure that vectors constructed have the same 
> > > > > representation.
> > > > >            We only tested element precision and modes to match.
> > > > >            Vectors may be BLKmode and thus also check that the number 
> > > > > of
> > > > >            parts match.  */
> > > > > -       if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)),
> > > > > -                     TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1))))
> > > > > +       if (maybe_ne (TYPE_VECTOR_SUBPARTS (type0),
> > > > > +                     TYPE_VECTOR_SUBPARTS (type1)))
> > > > >           return false;
> > > > >
> > > > >         vec<constructor_elt, va_gc> *v0 = CONSTRUCTOR_ELTS (arg0);
> > > > >
> > > > >
> > > > >
> > > > >
> > > > > --

Reply via email to