RFC: Make builtin types only valid for some target features

RFC: Make builtin types only valid for some target features

[Kewen.Lin]

Hi,

I'm working to find one solution for PR106736, which requires us to
make some built-in types only valid for some target features, and
emit error messages for the types when the condition isn't satisfied.  
A straightforward idea is to guard the registry of built-in type under
the corresponding target feature.  But as Peter pointed out in the
PR, it doesn't work, as these built-in types are used by some built-in
functions which are required to be initialized always regardless of
target features, in order to support target pragma/attribute.  For
the validity checking on the built-in functions, it happens during
expanding the built-in functions calls, since till then we already
know the exact information on specific target feature.

One idea is to support built-in type checking in a similar way, to
check if all used type_decl (built-in type) are valid or not somewhere.
I hacked to simply check currently expanding gimple stmt is gassign
and further check the types of its operands, it did work but checking
gassign isn't enough.  Maybe I missed something, there seems not an
efficient way for a full check IMHO.

So I tried another direction, which was inspired by the existing
attribute altivec, to introduce an artificial type attribute and the
corresponding macro definition, during attribute handling it can check
target option node about target feature for validity.  The advantage
is that the checking happens in FE, so it reports error early, and it
doesn't need a later full checking on types.  But with some prototyping
work, I found one issue that it doesn't support param decl well, since
the handling on attributes of function decl happens after that on
attributes of param decl, so we aren't able to get exact target feature
information when handling the attributes on param decl.  It requires
front-end needs to change the parsing order, I guess it's not acceptable?
So I planed to give up and return to the previous direction.

Does the former idea sound good?  Any comments/suggestions, and other
ideas?

Thanks a lot in advance!

BR,
Kewen

Re: RFC: Make builtin types only valid for some target features

[Richard Sandiford]

"Kewen.Lin" <linkw@linux.ibm.com> writes:
> Hi,
>
> I'm working to find one solution for PR106736, which requires us to
> make some built-in types only valid for some target features, and
> emit error messages for the types when the condition isn't satisfied.  
> A straightforward idea is to guard the registry of built-in type under
> the corresponding target feature.  But as Peter pointed out in the
> PR, it doesn't work, as these built-in types are used by some built-in
> functions which are required to be initialized always regardless of
> target features, in order to support target pragma/attribute.  For
> the validity checking on the built-in functions, it happens during
> expanding the built-in functions calls, since till then we already
> know the exact information on specific target feature.
>
> One idea is to support built-in type checking in a similar way, to
> check if all used type_decl (built-in type) are valid or not somewhere.
> I hacked to simply check currently expanding gimple stmt is gassign
> and further check the types of its operands, it did work but checking
> gassign isn't enough.  Maybe I missed something, there seems not an
> efficient way for a full check IMHO.
>
> So I tried another direction, which was inspired by the existing
> attribute altivec, to introduce an artificial type attribute and the
> corresponding macro definition, during attribute handling it can check
> target option node about target feature for validity.  The advantage
> is that the checking happens in FE, so it reports error early, and it
> doesn't need a later full checking on types.  But with some prototyping
> work, I found one issue that it doesn't support param decl well, since
> the handling on attributes of function decl happens after that on
> attributes of param decl, so we aren't able to get exact target feature
> information when handling the attributes on param decl.  It requires
> front-end needs to change the parsing order, I guess it's not acceptable?
> So I planed to give up and return to the previous direction.
>
> Does the former idea sound good?  Any comments/suggestions, and other
> ideas?
>
> Thanks a lot in advance!

FWIW, the aarch64 fp move patterns emit the error directly.  They then
expand an integer-mode move, to provide some error recovery.  (The
alternative would be to make the error fatal.)

(define_expand "mov<mode>"
  [(set (match_operand:GPF_TF_F16_MOV 0 "nonimmediate_operand")
	(match_operand:GPF_TF_F16_MOV 1 "general_operand"))]
  ""
  {
    if (!TARGET_FLOAT)
      {
	aarch64_err_no_fpadvsimd (<MODE>mode);
	machine_mode intmode
	  = int_mode_for_size (GET_MODE_BITSIZE (<MODE>mode), 0).require ();
	emit_move_insn (gen_lowpart (intmode, operands[0]),
			gen_lowpart (intmode, operands[1]));
	DONE;
      }

This isn't as user-friendly as catching the error directly in the FE,
but I think in practice it's going to be very hard to trap all invalid
uses of a type there.  Also, the user error in these situations is likely
to be forgetting to enable the right architecture feature, rather than
accidentally using the wrong type.  So an error about missing architecture
features is probably good enough in most cases.

Thanks,
Richard

Re: RFC: Make builtin types only valid for some target features

[Andrew Pinski]

On Sun, Dec 4, 2022 at 11:33 PM Richard Sandiford via Gcc
<gcc@gcc.gnu.org> wrote:
>
> "Kewen.Lin" <linkw@linux.ibm.com> writes:
> > Hi,
> >
> > I'm working to find one solution for PR106736, which requires us to
> > make some built-in types only valid for some target features, and
> > emit error messages for the types when the condition isn't satisfied.
> > A straightforward idea is to guard the registry of built-in type under
> > the corresponding target feature.  But as Peter pointed out in the
> > PR, it doesn't work, as these built-in types are used by some built-in
> > functions which are required to be initialized always regardless of
> > target features, in order to support target pragma/attribute.  For
> > the validity checking on the built-in functions, it happens during
> > expanding the built-in functions calls, since till then we already
> > know the exact information on specific target feature.
> >
> > One idea is to support built-in type checking in a similar way, to
> > check if all used type_decl (built-in type) are valid or not somewhere.
> > I hacked to simply check currently expanding gimple stmt is gassign
> > and further check the types of its operands, it did work but checking
> > gassign isn't enough.  Maybe I missed something, there seems not an
> > efficient way for a full check IMHO.
> >
> > So I tried another direction, which was inspired by the existing
> > attribute altivec, to introduce an artificial type attribute and the
> > corresponding macro definition, during attribute handling it can check
> > target option node about target feature for validity.  The advantage
> > is that the checking happens in FE, so it reports error early, and it
> > doesn't need a later full checking on types.  But with some prototyping
> > work, I found one issue that it doesn't support param decl well, since
> > the handling on attributes of function decl happens after that on
> > attributes of param decl, so we aren't able to get exact target feature
> > information when handling the attributes on param decl.  It requires
> > front-end needs to change the parsing order, I guess it's not acceptable?
> > So I planed to give up and return to the previous direction.
> >
> > Does the former idea sound good?  Any comments/suggestions, and other
> > ideas?
> >
> > Thanks a lot in advance!
>
> FWIW, the aarch64 fp move patterns emit the error directly.  They then
> expand an integer-mode move, to provide some error recovery.  (The
> alternative would be to make the error fatal.)
>
> (define_expand "mov<mode>"
>   [(set (match_operand:GPF_TF_F16_MOV 0 "nonimmediate_operand")
>         (match_operand:GPF_TF_F16_MOV 1 "general_operand"))]
>   ""
>   {
>     if (!TARGET_FLOAT)
>       {
>         aarch64_err_no_fpadvsimd (<MODE>mode);
>         machine_mode intmode
>           = int_mode_for_size (GET_MODE_BITSIZE (<MODE>mode), 0).require ();
>         emit_move_insn (gen_lowpart (intmode, operands[0]),
>                         gen_lowpart (intmode, operands[1]));
>         DONE;
>       }
>
> This isn't as user-friendly as catching the error directly in the FE,
> but I think in practice it's going to be very hard to trap all invalid
> uses of a type there.  Also, the user error in these situations is likely
> to be forgetting to enable the right architecture feature, rather than
> accidentally using the wrong type.  So an error about missing architecture
> features is probably good enough in most cases.

I did have a patch which improved the situation for the SVE types to
provide an error message at compile time when SVE is not enabled
but I didn't get any feedback from either the C or C++ front-end folks.
https://gcc.gnu.org/pipermail/gcc-patches/2021-November/583786.html

I suspect if that patch gets reviewed by the front-end folks, Kewen
could use the same infrastructure to error out on the types for rs6000
backend.


Thanks,
Andrew Pinski

>
> Thanks,
> Richard

Re: RFC: Make builtin types only valid for some target features

[Kewen.Lin]

Hi Richard,

on 2022/12/5 15:31, Richard Sandiford wrote:
> "Kewen.Lin" <linkw@linux.ibm.com> writes:
>> Hi,
>>
>> I'm working to find one solution for PR106736, which requires us to
>> make some built-in types only valid for some target features, and
>> emit error messages for the types when the condition isn't satisfied.  
>> A straightforward idea is to guard the registry of built-in type under
>> the corresponding target feature.  But as Peter pointed out in the
>> PR, it doesn't work, as these built-in types are used by some built-in
>> functions which are required to be initialized always regardless of
>> target features, in order to support target pragma/attribute.  For
>> the validity checking on the built-in functions, it happens during
>> expanding the built-in functions calls, since till then we already
>> know the exact information on specific target feature.
>>
>> One idea is to support built-in type checking in a similar way, to
>> check if all used type_decl (built-in type) are valid or not somewhere.
>> I hacked to simply check currently expanding gimple stmt is gassign
>> and further check the types of its operands, it did work but checking
>> gassign isn't enough.  Maybe I missed something, there seems not an
>> efficient way for a full check IMHO.
>>
>> So I tried another direction, which was inspired by the existing
>> attribute altivec, to introduce an artificial type attribute and the
>> corresponding macro definition, during attribute handling it can check
>> target option node about target feature for validity.  The advantage
>> is that the checking happens in FE, so it reports error early, and it
>> doesn't need a later full checking on types.  But with some prototyping
>> work, I found one issue that it doesn't support param decl well, since
>> the handling on attributes of function decl happens after that on
>> attributes of param decl, so we aren't able to get exact target feature
>> information when handling the attributes on param decl.  It requires
>> front-end needs to change the parsing order, I guess it's not acceptable?
>> So I planed to give up and return to the previous direction.
>>
>> Does the former idea sound good?  Any comments/suggestions, and other
>> ideas?
>>
>> Thanks a lot in advance!
> 
> FWIW, the aarch64 fp move patterns emit the error directly.  They then
> expand an integer-mode move, to provide some error recovery.  (The
> alternative would be to make the error fatal.)
> 
> (define_expand "mov<mode>"
>   [(set (match_operand:GPF_TF_F16_MOV 0 "nonimmediate_operand")
> 	(match_operand:GPF_TF_F16_MOV 1 "general_operand"))]
>   ""
>   {
>     if (!TARGET_FLOAT)
>       {
> 	aarch64_err_no_fpadvsimd (<MODE>mode);
> 	machine_mode intmode
> 	  = int_mode_for_size (GET_MODE_BITSIZE (<MODE>mode), 0).require ();
> 	emit_move_insn (gen_lowpart (intmode, operands[0]),
> 			gen_lowpart (intmode, operands[1]));
> 	DONE;
>       }
> 
> This isn't as user-friendly as catching the error directly in the FE,
> but I think in practice it's going to be very hard to trap all invalid
> uses of a type there.  Also, the user error in these situations is likely
> to be forgetting to enable the right architecture feature, rather than
> accidentally using the wrong type.  So an error about missing architecture
> features is probably good enough in most cases.
> 

Thanks a lot for your comments!  Yes, it's a question if it's worth to
spending non-trivial efforts to check and report all invalid uses.  For
the case in PR106736, it's enough to check in mov[ox]o define_expand
like the example you provided above, one trial patch was posted previously
at[1].  I think one difference is that we want to further check the actual
type instead of the mode, as Peter said "'types' are limited to MMA, but
the opaque modes are not limited to MMA.".

[1] https://gcc.gnu.org/bugzilla/attachment.cgi?id=53522&action=diff

BR,
Kewen

Re: RFC: Make builtin types only valid for some target features

[Segher Boessenkool]

On Mon, Dec 05, 2022 at 07:31:48AM +0000, Richard Sandiford wrote:
> FWIW, the aarch64 fp move patterns emit the error directly.  They then
> expand an integer-mode move, to provide some error recovery.  (The
> alternative would be to make the error fatal.)
> 
> (define_expand "mov<mode>"
>   [(set (match_operand:GPF_TF_F16_MOV 0 "nonimmediate_operand")
> 	(match_operand:GPF_TF_F16_MOV 1 "general_operand"))]
>   ""
>   {
>     if (!TARGET_FLOAT)
>       {
> 	aarch64_err_no_fpadvsimd (<MODE>mode);
> 	machine_mode intmode
> 	  = int_mode_for_size (GET_MODE_BITSIZE (<MODE>mode), 0).require ();
> 	emit_move_insn (gen_lowpart (intmode, operands[0]),
> 			gen_lowpart (intmode, operands[1]));
> 	DONE;
>       }
> 
> This isn't as user-friendly as catching the error directly in the FE,
> but I think in practice it's going to be very hard to trap all invalid
> uses of a type there.  Also, the user error in these situations is likely
> to be forgetting to enable the right architecture feature, rather than
> accidentally using the wrong type.  So an error about missing architecture
> features is probably good enough in most cases.

The obvious problwem with this is you have to write it separately for
each and every such pattern.  But of course the opaque modes only ever
have mov patterns, everything else goes via builtins, so if this is the
best we can easily do, so be it :-)

Thanks,


Segher

Re: RFC: Make builtin types only valid for some target features

[Kewen.Lin]

Hi Andrew,

on 2022/12/5 18:10, Andrew Pinski wrote:
> On Sun, Dec 4, 2022 at 11:33 PM Richard Sandiford via Gcc
> <gcc@gcc.gnu.org> wrote:
>>
>> "Kewen.Lin" <linkw@linux.ibm.com> writes:
>>> Hi,
>>>
>>> I'm working to find one solution for PR106736, which requires us to
>>> make some built-in types only valid for some target features, and
>>> emit error messages for the types when the condition isn't satisfied.
>>> A straightforward idea is to guard the registry of built-in type under
>>> the corresponding target feature.  But as Peter pointed out in the
>>> PR, it doesn't work, as these built-in types are used by some built-in
>>> functions which are required to be initialized always regardless of
>>> target features, in order to support target pragma/attribute.  For
>>> the validity checking on the built-in functions, it happens during
>>> expanding the built-in functions calls, since till then we already
>>> know the exact information on specific target feature.
>>>
>>> One idea is to support built-in type checking in a similar way, to
>>> check if all used type_decl (built-in type) are valid or not somewhere.
>>> I hacked to simply check currently expanding gimple stmt is gassign
>>> and further check the types of its operands, it did work but checking
>>> gassign isn't enough.  Maybe I missed something, there seems not an
>>> efficient way for a full check IMHO.
>>>
>>> So I tried another direction, which was inspired by the existing
>>> attribute altivec, to introduce an artificial type attribute and the
>>> corresponding macro definition, during attribute handling it can check
>>> target option node about target feature for validity.  The advantage
>>> is that the checking happens in FE, so it reports error early, and it
>>> doesn't need a later full checking on types.  But with some prototyping
>>> work, I found one issue that it doesn't support param decl well, since
>>> the handling on attributes of function decl happens after that on
>>> attributes of param decl, so we aren't able to get exact target feature
>>> information when handling the attributes on param decl.  It requires
>>> front-end needs to change the parsing order, I guess it's not acceptable?
>>> So I planed to give up and return to the previous direction.
>>>
>>> Does the former idea sound good?  Any comments/suggestions, and other
>>> ideas?
>>>
>>> Thanks a lot in advance!
>>
>> FWIW, the aarch64 fp move patterns emit the error directly.  They then
>> expand an integer-mode move, to provide some error recovery.  (The
>> alternative would be to make the error fatal.)
>>
>> (define_expand "mov<mode>"
>>   [(set (match_operand:GPF_TF_F16_MOV 0 "nonimmediate_operand")
>>         (match_operand:GPF_TF_F16_MOV 1 "general_operand"))]
>>   ""
>>   {
>>     if (!TARGET_FLOAT)
>>       {
>>         aarch64_err_no_fpadvsimd (<MODE>mode);
>>         machine_mode intmode
>>           = int_mode_for_size (GET_MODE_BITSIZE (<MODE>mode), 0).require ();
>>         emit_move_insn (gen_lowpart (intmode, operands[0]),
>>                         gen_lowpart (intmode, operands[1]));
>>         DONE;
>>       }
>>
>> This isn't as user-friendly as catching the error directly in the FE,
>> but I think in practice it's going to be very hard to trap all invalid
>> uses of a type there.  Also, the user error in these situations is likely
>> to be forgetting to enable the right architecture feature, rather than
>> accidentally using the wrong type.  So an error about missing architecture
>> features is probably good enough in most cases.
> 
> I did have a patch which improved the situation for the SVE types to
> provide an error message at compile time when SVE is not enabled
> but I didn't get any feedback from either the C or C++ front-end folks.
> https://gcc.gnu.org/pipermail/gcc-patches/2021-November/583786.html
> 

Nice!  Many thanks for providing this new direction.

> I suspect if that patch gets reviewed by the front-end folks, Kewen
> could use the same infrastructure to error out on the types for rs6000
> backend.

Yeah, I just confirmed that on top of your patch introducing function
rs6000_verify_type_context to take care of those MMA types can fix the
issue in PR106736.  TBH, I'm not sure if your patch can cover all
possible places where a built-in type can be used, but I guess it can
cover the most.

BR,
Kewen