[1/2,RFC,17] [middle-end: Supporting multi character string formatters

  Today asm print operands are required to be single characters.  This means we're
quite limited in the number of them we can have and they are threated as white
gold in many backends.

This causes us to have to do some hack solutions in the backends for instance to
support some SME operations just to avoid new print operands.

This patch extends the parsers to support multiple token operands and extends
the print_operand target hook to pass a pointer to the buffer being read so the
backend can consume as many tokens as it needs.

As a consequence backends are completely free to choose how their multi letter
operands look like.

There will need to be a mechanical change in all targets doing

int code = p ? (unsigned char)**p : 0;

to support this new interface.

There is one restriction in that whatever the backends choose should not overlap
with assembler dialect support.  This means that %{, &|,  %} are reserved.

I am wondering however if there is apetite to try to see if we can standardise
on a syntax for multi character operands or whether we shouldn't try.

One possible way is to do what we do for constraints, where you specify a letter
to start the multi letter parsing and a fixed number of character to parse.

However this is annoying as it still makes us make cryptic names.

In the AArch64 example patch I chose %[..] so e.g. %[SME_VC]0 but I don't quite
like it. I could do instead %SME_VC:0? i.e. if the character following the
current one isn't a digit, consume until a : is found.

Bootstrapped Regtested on aarch64-none-linux-gnu and no issues.

Thoughts?

Thanks,
Tamar

gcc/ChangeLog:

	* target.def (print_operand): Modify with new pointer.
	* targhooks.cc (default_print_operand): Update using pointer.
	* targhooks.h (default_print_operand): Likewise.
	* config/aarch64/aarch64.cc (aarch64_print_operand): Update
	* final.cc (output_asm_insn): Update to new target hook format.
	(output_operand): Likewise.
	* output.h (output_operand): Likewise.

---


--
  

On 08/04/2026 09:18, Tamar Christina wrote:
> Today asm print operands are required to be single characters.  This means we're
> quite limited in the number of them we can have and they are threated as white
> gold in many backends.
> 
> This causes us to have to do some hack solutions in the backends for instance to
> support some SME operations just to avoid new print operands.
> 
> This patch extends the parsers to support multiple token operands and extends
> the print_operand target hook to pass a pointer to the buffer being read so the
> backend can consume as many tokens as it needs.
> 
> As a consequence backends are completely free to choose how their multi letter
> operands look like.
> 
> There will need to be a mechanical change in all targets doing
> 
> int code = p ? (unsigned char)**p : 0;
> 
> to support this new interface.
> 
> There is one restriction in that whatever the backends choose should not overlap
> with assembler dialect support.  This means that %{, &|,  %} are reserved.
> 
> I am wondering however if there is apetite to try to see if we can standardise
> on a syntax for multi character operands or whether we shouldn't try.
> 
> One possible way is to do what we do for constraints, where you specify a letter
> to start the multi letter parsing and a fixed number of character to parse.
> 
> However this is annoying as it still makes us make cryptic names.
> 
> In the AArch64 example patch I chose %[..] so e.g. %[SME_VC]0 but I don't quite
> like it. I could do instead %SME_VC:0? i.e. if the character following the
> current one isn't a digit, consume until a : is found.
> 
> Bootstrapped Regtested on aarch64-none-linux-gnu and no issues.
> 

This would be a nice improvement.

We currently have an int for the code, but only use a limited set of ascii values with that.  Did you consider having a mapping function that could read the extended formats and convert it to an int code for the extended values?  That would mean you wouldn't need to touch backends that haven't added the parsing hook and would provide separation between reading a string code and the backend processing of the value: the default hook would simply read a char as before.

Something like:
 	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
-	  output_operand (NULL_RTX, *p++);
+         output_operand (NULL_RTX, targetm.asm_out.print_operand_punct_code (&p);
        else
...

Any code above, say, 255 could be used by a backend.

What's more, most existing code that passes a hard-coded letter wouldn't need changing at all.

R.

> Thoughts?
> 
> Thanks,
> Tamar
> 
> gcc/ChangeLog:
> 
> 	* target.def (print_operand): Modify with new pointer.
> 	* targhooks.cc (default_print_operand): Update using pointer.
> 	* targhooks.h (default_print_operand): Likewise.
> 	* config/aarch64/aarch64.cc (aarch64_print_operand): Update
> 	* final.cc (output_asm_insn): Update to new target hook format.
> 	(output_operand): Likewise.
> 	* output.h (output_operand): Likewise.
> 
> ---
> diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
> index 1902a4ee9fa34a1f00e654760d0759af1d6cf432..1bf54641f581e90bb629d2fcd2f0d32a2c9474f9 100644
> --- a/gcc/config/aarch64/aarch64.cc
> +++ b/gcc/config/aarch64/aarch64.cc
> @@ -13009,9 +13009,10 @@ sizetochar (int size)
>       'z':		Output address of a typical LDP or STP.  */
>  
>  static void
> -aarch64_print_operand (FILE *f, rtx x, int code)
> +aarch64_print_operand (FILE *f, rtx x, const char * const *p)
>  {
>    rtx elt;
> +  int code = p ? (unsigned char)**p : 0;
>    switch (code)
>      {
>      case 'c':
> diff --git a/gcc/final.cc b/gcc/final.cc
> index b5e8c6e2efde01417370e7dea5456ba108b866ed..fcb8877f8814c4594f3a4ddc0da03e631653caf4 100644
> --- a/gcc/final.cc
> +++ b/gcc/final.cc
> @@ -3508,6 +3508,7 @@ output_asm_insn (const char *templ, rtx *operands)
>  	   the TARGET_PRINT_OPERAND hook can define them.  */
>  	else if (ISALPHA (*p))
>  	  {
> +	    const char *p_init = p;
>  	    int letter = *p++;
>  	    unsigned long opnum;
>  	    char *endptr;
> @@ -3535,7 +3536,7 @@ output_asm_insn (const char *templ, rtx *operands)
>  		if (letter2 == 'c' || CONSTANT_ADDRESS_P (operands[opnum]))
>  		  output_addr_const (asm_out_file, operands[opnum]);
>  		else
> -		  output_operand (operands[opnum], 'c');
> +		  output_operand (operands[opnum], &p_init);
>  	      }
>  	    else if (letter == 'n')
>  	      {
> @@ -3549,7 +3550,7 @@ output_asm_insn (const char *templ, rtx *operands)
>  		  }
>  	      }
>  	    else
> -	      output_operand (operands[opnum], letter);
> +	      output_operand (operands[opnum], &p_init);
>  
>  	    if (!opoutput[opnum])
>  	      oporder[ops++] = opnum;
> @@ -3585,7 +3586,10 @@ output_asm_insn (const char *templ, rtx *operands)
>  	   punctuation character alone, with no operand.  The
>  	   TARGET_PRINT_OPERAND hook decides what is actually done.  */
>  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
> -	  output_operand (NULL_RTX, *p++);
> +	  {
> +	    const char *ptr = p++;
> +	    output_operand (NULL_RTX, &ptr);
> +	  }
>  	else
>  	  output_operand_lossage ("invalid %%-code");
>  	break;
> @@ -3651,7 +3655,7 @@ mark_symbol_refs_as_used (rtx x)
>     by TARGET_PRINT_OPERAND.  */
>  
>  void
> -output_operand (rtx x, int code ATTRIBUTE_UNUSED)
> +output_operand (rtx x, const char * const *p ATTRIBUTE_UNUSED)
>  {
>    if (x && GET_CODE (x) == SUBREG)
>      x = alter_subreg (&x, true);
> @@ -3660,7 +3664,7 @@ output_operand (rtx x, int code ATTRIBUTE_UNUSED)
>    if (!targetm.no_register_allocation)
>      gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
>  
> -  targetm.asm_out.print_operand (asm_out_file, x, code);
> +  targetm.asm_out.print_operand (asm_out_file, x, p);
>  
>    if (x == NULL_RTX)
>      return;
> diff --git a/gcc/output.h b/gcc/output.h
> index 1f628ea2371aeca006d686e521a04d4f7ddb6e2d..101f4f8ed14808f37ab455e2cb9e68a3edd237f3 100644
> --- a/gcc/output.h
> +++ b/gcc/output.h
> @@ -79,7 +79,7 @@ extern rtx_insn *final_scan_insn (rtx_insn *, FILE *, int, int, int *);
>  extern rtx alter_subreg (rtx *, bool);
>  
>  /* Print an operand using machine-dependent assembler syntax.  */
> -extern void output_operand (rtx, int);
> +extern void output_operand (rtx, const char * const *);
>  
>  /* Report inconsistency between the assembler template and the operands.
>     In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
> diff --git a/gcc/target.def b/gcc/target.def
> index 206c94f8749ba8f242229d36da0049826c342502..793f64da9c0abb4ca470e6e9be0cd5eb1a859886 100644
> --- a/gcc/target.def
> +++ b/gcc/target.def
> @@ -892,7 +892,7 @@ return @code{true}.",
>  DEFHOOK_UNDOC
>  (print_operand,
>   "",
> - void, (FILE *file, rtx x, int code),
> + void, (FILE *file, rtx x, const char * const * p),
>   default_print_operand)
>  
>  /* Emit a machine-specific memory address.  */
> diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
> index 5f1eac75122c9cc945012a02426784f6c2584328..63cefae50f8854992b3fb7d5ad8a32cf9511208a 100644
> --- a/gcc/targhooks.cc
> +++ b/gcc/targhooks.cc
> @@ -390,7 +390,7 @@ hook_callee_copies_named (cumulative_args_t, const function_arg_info &arg)
>  
>  void
>  default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
> -		       int code ATTRIBUTE_UNUSED)
> +		       const char * const *p ATTRIBUTE_UNUSED)
>  {
>  #ifdef PRINT_OPERAND
>    PRINT_OPERAND (stream, x, code);
> diff --git a/gcc/targhooks.h b/gcc/targhooks.h
> index 9582233e69fee1b56ab9d2f2573707621f9837ff..3031e08e84e7f1401d0fd08bf8e16c37f78c98c9 100644
> --- a/gcc/targhooks.h
> +++ b/gcc/targhooks.h
> @@ -74,7 +74,7 @@ extern bool hook_pass_by_reference_must_pass_in_stack
>  extern bool hook_callee_copies_named
>    (cumulative_args_t ca, const function_arg_info &);
>  
> -extern void default_print_operand (FILE *, rtx, int);
> +extern void default_print_operand (FILE *, rtx, const char * const *);
>  extern void default_print_operand_address (FILE *, machine_mode, rtx);
>  extern bool default_print_operand_punct_valid_p (unsigned char);
>  extern tree default_mangle_assembler_name (const char *);
> 
>
  

On Wed, 8 Apr 2026, Richard Earnshaw (foss) wrote:

> On 08/04/2026 09:18, Tamar Christina wrote:
> > Today asm print operands are required to be single characters.  This means we're
> > quite limited in the number of them we can have and they are threated as white
> > gold in many backends.
> > 
> > This causes us to have to do some hack solutions in the backends for instance to
> > support some SME operations just to avoid new print operands.
> > 
> > This patch extends the parsers to support multiple token operands and extends
> > the print_operand target hook to pass a pointer to the buffer being read so the
> > backend can consume as many tokens as it needs.
> > 
> > As a consequence backends are completely free to choose how their multi letter
> > operands look like.
> > 
> > There will need to be a mechanical change in all targets doing
> > 
> > int code = p ? (unsigned char)**p : 0;
> > 
> > to support this new interface.
> > 
> > There is one restriction in that whatever the backends choose should not overlap
> > with assembler dialect support.  This means that %{, &|,  %} are reserved.
> > 
> > I am wondering however if there is apetite to try to see if we can standardise
> > on a syntax for multi character operands or whether we shouldn't try.
> > 
> > One possible way is to do what we do for constraints, where you specify a letter
> > to start the multi letter parsing and a fixed number of character to parse.
> > 
> > However this is annoying as it still makes us make cryptic names.
> > 
> > In the AArch64 example patch I chose %[..] so e.g. %[SME_VC]0 but I don't quite
> > like it. I could do instead %SME_VC:0? i.e. if the character following the
> > current one isn't a digit, consume until a : is found.
> > 
> > Bootstrapped Regtested on aarch64-none-linux-gnu and no issues.
> > 
> 
> This would be a nice improvement.
> 
> We currently have an int for the code, but only use a limited set of ascii values with that.  Did you consider having a mapping function that could read the extended formats and convert it to an int code for the extended values?  That would mean you wouldn't need to touch backends that haven't added the parsing hook and would provide separation between reading a string code and the backend processing of the value: the default hook would simply read a char as before.
> 
> Something like:
>  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
> -	  output_operand (NULL_RTX, *p++);
> +         output_operand (NULL_RTX, targetm.asm_out.print_operand_punct_code (&p);

Or add &p as extra arg to the valid_p hook.  Or make
targetm.asm_out.print_operand_punct_code return single-char code as 
well and hopefully reserved -1 or 0 as error.

Richard.

>         else
> ...
> 
> Any code above, say, 255 could be used by a backend.
> 
> What's more, most existing code that passes a hard-coded letter wouldn't need changing at all.
> 
> R.
> 
> > Thoughts?
> > 
> > Thanks,
> > Tamar
> > 
> > gcc/ChangeLog:
> > 
> > 	* target.def (print_operand): Modify with new pointer.
> > 	* targhooks.cc (default_print_operand): Update using pointer.
> > 	* targhooks.h (default_print_operand): Likewise.
> > 	* config/aarch64/aarch64.cc (aarch64_print_operand): Update
> > 	* final.cc (output_asm_insn): Update to new target hook format.
> > 	(output_operand): Likewise.
> > 	* output.h (output_operand): Likewise.
> > 
> > ---
> > diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc
> > index 1902a4ee9fa34a1f00e654760d0759af1d6cf432..1bf54641f581e90bb629d2fcd2f0d32a2c9474f9 100644
> > --- a/gcc/config/aarch64/aarch64.cc
> > +++ b/gcc/config/aarch64/aarch64.cc
> > @@ -13009,9 +13009,10 @@ sizetochar (int size)
> >       'z':		Output address of a typical LDP or STP.  */
> >  
> >  static void
> > -aarch64_print_operand (FILE *f, rtx x, int code)
> > +aarch64_print_operand (FILE *f, rtx x, const char * const *p)
> >  {
> >    rtx elt;
> > +  int code = p ? (unsigned char)**p : 0;
> >    switch (code)
> >      {
> >      case 'c':
> > diff --git a/gcc/final.cc b/gcc/final.cc
> > index b5e8c6e2efde01417370e7dea5456ba108b866ed..fcb8877f8814c4594f3a4ddc0da03e631653caf4 100644
> > --- a/gcc/final.cc
> > +++ b/gcc/final.cc
> > @@ -3508,6 +3508,7 @@ output_asm_insn (const char *templ, rtx *operands)
> >  	   the TARGET_PRINT_OPERAND hook can define them.  */
> >  	else if (ISALPHA (*p))
> >  	  {
> > +	    const char *p_init = p;
> >  	    int letter = *p++;
> >  	    unsigned long opnum;
> >  	    char *endptr;
> > @@ -3535,7 +3536,7 @@ output_asm_insn (const char *templ, rtx *operands)
> >  		if (letter2 == 'c' || CONSTANT_ADDRESS_P (operands[opnum]))
> >  		  output_addr_const (asm_out_file, operands[opnum]);
> >  		else
> > -		  output_operand (operands[opnum], 'c');
> > +		  output_operand (operands[opnum], &p_init);
> >  	      }
> >  	    else if (letter == 'n')
> >  	      {
> > @@ -3549,7 +3550,7 @@ output_asm_insn (const char *templ, rtx *operands)
> >  		  }
> >  	      }
> >  	    else
> > -	      output_operand (operands[opnum], letter);
> > +	      output_operand (operands[opnum], &p_init);
> >  
> >  	    if (!opoutput[opnum])
> >  	      oporder[ops++] = opnum;
> > @@ -3585,7 +3586,10 @@ output_asm_insn (const char *templ, rtx *operands)
> >  	   punctuation character alone, with no operand.  The
> >  	   TARGET_PRINT_OPERAND hook decides what is actually done.  */
> >  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
> > -	  output_operand (NULL_RTX, *p++);
> > +	  {
> > +	    const char *ptr = p++;
> > +	    output_operand (NULL_RTX, &ptr);
> > +	  }
> >  	else
> >  	  output_operand_lossage ("invalid %%-code");
> >  	break;
> > @@ -3651,7 +3655,7 @@ mark_symbol_refs_as_used (rtx x)
> >     by TARGET_PRINT_OPERAND.  */
> >  
> >  void
> > -output_operand (rtx x, int code ATTRIBUTE_UNUSED)
> > +output_operand (rtx x, const char * const *p ATTRIBUTE_UNUSED)
> >  {
> >    if (x && GET_CODE (x) == SUBREG)
> >      x = alter_subreg (&x, true);
> > @@ -3660,7 +3664,7 @@ output_operand (rtx x, int code ATTRIBUTE_UNUSED)
> >    if (!targetm.no_register_allocation)
> >      gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
> >  
> > -  targetm.asm_out.print_operand (asm_out_file, x, code);
> > +  targetm.asm_out.print_operand (asm_out_file, x, p);
> >  
> >    if (x == NULL_RTX)
> >      return;
> > diff --git a/gcc/output.h b/gcc/output.h
> > index 1f628ea2371aeca006d686e521a04d4f7ddb6e2d..101f4f8ed14808f37ab455e2cb9e68a3edd237f3 100644
> > --- a/gcc/output.h
> > +++ b/gcc/output.h
> > @@ -79,7 +79,7 @@ extern rtx_insn *final_scan_insn (rtx_insn *, FILE *, int, int, int *);
> >  extern rtx alter_subreg (rtx *, bool);
> >  
> >  /* Print an operand using machine-dependent assembler syntax.  */
> > -extern void output_operand (rtx, int);
> > +extern void output_operand (rtx, const char * const *);
> >  
> >  /* Report inconsistency between the assembler template and the operands.
> >     In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
> > diff --git a/gcc/target.def b/gcc/target.def
> > index 206c94f8749ba8f242229d36da0049826c342502..793f64da9c0abb4ca470e6e9be0cd5eb1a859886 100644
> > --- a/gcc/target.def
> > +++ b/gcc/target.def
> > @@ -892,7 +892,7 @@ return @code{true}.",
> >  DEFHOOK_UNDOC
> >  (print_operand,
> >   "",
> > - void, (FILE *file, rtx x, int code),
> > + void, (FILE *file, rtx x, const char * const * p),
> >   default_print_operand)
> >  
> >  /* Emit a machine-specific memory address.  */
> > diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
> > index 5f1eac75122c9cc945012a02426784f6c2584328..63cefae50f8854992b3fb7d5ad8a32cf9511208a 100644
> > --- a/gcc/targhooks.cc
> > +++ b/gcc/targhooks.cc
> > @@ -390,7 +390,7 @@ hook_callee_copies_named (cumulative_args_t, const function_arg_info &arg)
> >  
> >  void
> >  default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
> > -		       int code ATTRIBUTE_UNUSED)
> > +		       const char * const *p ATTRIBUTE_UNUSED)
> >  {
> >  #ifdef PRINT_OPERAND
> >    PRINT_OPERAND (stream, x, code);
> > diff --git a/gcc/targhooks.h b/gcc/targhooks.h
> > index 9582233e69fee1b56ab9d2f2573707621f9837ff..3031e08e84e7f1401d0fd08bf8e16c37f78c98c9 100644
> > --- a/gcc/targhooks.h
> > +++ b/gcc/targhooks.h
> > @@ -74,7 +74,7 @@ extern bool hook_pass_by_reference_must_pass_in_stack
> >  extern bool hook_callee_copies_named
> >    (cumulative_args_t ca, const function_arg_info &);
> >  
> > -extern void default_print_operand (FILE *, rtx, int);
> > +extern void default_print_operand (FILE *, rtx, const char * const *);
> >  extern void default_print_operand_address (FILE *, machine_mode, rtx);
> >  extern bool default_print_operand_punct_valid_p (unsigned char);
> >  extern tree default_mangle_assembler_name (const char *);
> > 
> > 
> 
>
  

> -----Original Message-----
> From: Richard Biener <rguenther@suse.de>
> Sent: 08 April 2026 13:10
> To: Richard Earnshaw <Richard.Earnshaw@arm.com>
> Cc: Tamar Christina <Tamar.Christina@arm.com>; gcc-patches@gcc.gnu.org;
> nd <nd@arm.com>; jeffreyalaw@gmail.com; rdapp.gcc@gmail.com;
> ktkachov@nvidia.com
> Subject: Re: [PATCH 1/2][RFC][GCC 17][middle-end: Supporting multi
> character string formatters
> 
> On Wed, 8 Apr 2026, Richard Earnshaw (foss) wrote:
> 
> > On 08/04/2026 09:18, Tamar Christina wrote:
> > > Today asm print operands are required to be single characters.  This means
> we're
> > > quite limited in the number of them we can have and they are threated as
> white
> > > gold in many backends.
> > >
> > > This causes us to have to do some hack solutions in the backends for
> instance to
> > > support some SME operations just to avoid new print operands.
> > >
> > > This patch extends the parsers to support multiple token operands and
> extends
> > > the print_operand target hook to pass a pointer to the buffer being read so
> the
> > > backend can consume as many tokens as it needs.
> > >
> > > As a consequence backends are completely free to choose how their multi
> letter
> > > operands look like.
> > >
> > > There will need to be a mechanical change in all targets doing
> > >
> > > int code = p ? (unsigned char)**p : 0;
> > >
> > > to support this new interface.
> > >
> > > There is one restriction in that whatever the backends choose should not
> overlap
> > > with assembler dialect support.  This means that %{, &|,  %} are reserved.
> > >
> > > I am wondering however if there is apetite to try to see if we can
> standardise
> > > on a syntax for multi character operands or whether we shouldn't try.
> > >
> > > One possible way is to do what we do for constraints, where you specify a
> letter
> > > to start the multi letter parsing and a fixed number of character to parse.
> > >
> > > However this is annoying as it still makes us make cryptic names.
> > >
> > > In the AArch64 example patch I chose %[..] so e.g. %[SME_VC]0 but I don't
> quite
> > > like it. I could do instead %SME_VC:0? i.e. if the character following the
> > > current one isn't a digit, consume until a : is found.
> > >
> > > Bootstrapped Regtested on aarch64-none-linux-gnu and no issues.
> > >
> >
> > This would be a nice improvement.
> >
> > We currently have an int for the code, but only use a limited set of ascii
> values with that.  Did you consider having a mapping function that could read
> the extended formats and convert it to an int code for the extended values?
> That would mean you wouldn't need to touch backends that haven't added
> the parsing hook and would provide separation between reading a string code
> and the backend processing of the value: the default hook would simply read a
> char as before.
> >
> > Something like:
> >  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned
> char) *p))
> > -	  output_operand (NULL_RTX, *p++);
> > +         output_operand (NULL_RTX,
> targetm.asm_out.print_operand_punct_code (&p);
> 
> Or add &p as extra arg to the valid_p hook.  Or make
> targetm.asm_out.print_operand_punct_code return single-char code as
> well and hopefully reserved -1 or 0 as error.
> 
> Richard.

I haven't considered this as I wanted to get some more descriptive names.
The numerical value could work, but that's even harder to remember though.

And this would escape into inline asm a user could write.

In particular something like %40 is hard to parse. Is this %4 on operand 0, or code 40?

It would need a larger change to the parser, because it atm unconditionally consumes
numerical operands before calling the target hook. i.e. %0 is consumed and just 0 passed
to the backend as a char.

But it's certainly possible, but how do we then deal with the ambiguity? (I still really want
more human friendly operands if possible though).

Thanks,
Tamar

> 
> >         else
> > ...
> >
> > Any code above, say, 255 could be used by a backend.
> >
> > What's more, most existing code that passes a hard-coded letter wouldn't
> need changing at all.
> >
> > R.
> >
> > > Thoughts?
> > >
> > > Thanks,
> > > Tamar
> > >
> > > gcc/ChangeLog:
> > >
> > > 	* target.def (print_operand): Modify with new pointer.
> > > 	* targhooks.cc (default_print_operand): Update using pointer.
> > > 	* targhooks.h (default_print_operand): Likewise.
> > > 	* config/aarch64/aarch64.cc (aarch64_print_operand): Update
> > > 	* final.cc (output_asm_insn): Update to new target hook format.
> > > 	(output_operand): Likewise.
> > > 	* output.h (output_operand): Likewise.
> > >
> > > ---
> > > diff --git a/gcc/config/aarch64/aarch64.cc
> b/gcc/config/aarch64/aarch64.cc
> > > index
> 1902a4ee9fa34a1f00e654760d0759af1d6cf432..1bf54641f581e90bb629d
> 2fcd2f0d32a2c9474f9 100644
> > > --- a/gcc/config/aarch64/aarch64.cc
> > > +++ b/gcc/config/aarch64/aarch64.cc
> > > @@ -13009,9 +13009,10 @@ sizetochar (int size)
> > >       'z':		Output address of a typical LDP or STP.  */
> > >
> > >  static void
> > > -aarch64_print_operand (FILE *f, rtx x, int code)
> > > +aarch64_print_operand (FILE *f, rtx x, const char * const *p)
> > >  {
> > >    rtx elt;
> > > +  int code = p ? (unsigned char)**p : 0;
> > >    switch (code)
> > >      {
> > >      case 'c':
> > > diff --git a/gcc/final.cc b/gcc/final.cc
> > > index
> b5e8c6e2efde01417370e7dea5456ba108b866ed..fcb8877f8814c4594f3a4
> ddc0da03e631653caf4 100644
> > > --- a/gcc/final.cc
> > > +++ b/gcc/final.cc
> > > @@ -3508,6 +3508,7 @@ output_asm_insn (const char *templ, rtx
> *operands)
> > >  	   the TARGET_PRINT_OPERAND hook can define them.  */
> > >  	else if (ISALPHA (*p))
> > >  	  {
> > > +	    const char *p_init = p;
> > >  	    int letter = *p++;
> > >  	    unsigned long opnum;
> > >  	    char *endptr;
> > > @@ -3535,7 +3536,7 @@ output_asm_insn (const char *templ, rtx
> *operands)
> > >  		if (letter2 == 'c' || CONSTANT_ADDRESS_P
> (operands[opnum]))
> > >  		  output_addr_const (asm_out_file, operands[opnum]);
> > >  		else
> > > -		  output_operand (operands[opnum], 'c');
> > > +		  output_operand (operands[opnum], &p_init);
> > >  	      }
> > >  	    else if (letter == 'n')
> > >  	      {
> > > @@ -3549,7 +3550,7 @@ output_asm_insn (const char *templ, rtx
> *operands)
> > >  		  }
> > >  	      }
> > >  	    else
> > > -	      output_operand (operands[opnum], letter);
> > > +	      output_operand (operands[opnum], &p_init);
> > >
> > >  	    if (!opoutput[opnum])
> > >  	      oporder[ops++] = opnum;
> > > @@ -3585,7 +3586,10 @@ output_asm_insn (const char *templ, rtx
> *operands)
> > >  	   punctuation character alone, with no operand.  The
> > >  	   TARGET_PRINT_OPERAND hook decides what is actually done.  */
> > >  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned
> char) *p))
> > > -	  output_operand (NULL_RTX, *p++);
> > > +	  {
> > > +	    const char *ptr = p++;
> > > +	    output_operand (NULL_RTX, &ptr);
> > > +	  }
> > >  	else
> > >  	  output_operand_lossage ("invalid %%-code");
> > >  	break;
> > > @@ -3651,7 +3655,7 @@ mark_symbol_refs_as_used (rtx x)
> > >     by TARGET_PRINT_OPERAND.  */
> > >
> > >  void
> > > -output_operand (rtx x, int code ATTRIBUTE_UNUSED)
> > > +output_operand (rtx x, const char * const *p ATTRIBUTE_UNUSED)
> > >  {
> > >    if (x && GET_CODE (x) == SUBREG)
> > >      x = alter_subreg (&x, true);
> > > @@ -3660,7 +3664,7 @@ output_operand (rtx x, int code
> ATTRIBUTE_UNUSED)
> > >    if (!targetm.no_register_allocation)
> > >      gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
> > >
> > > -  targetm.asm_out.print_operand (asm_out_file, x, code);
> > > +  targetm.asm_out.print_operand (asm_out_file, x, p);
> > >
> > >    if (x == NULL_RTX)
> > >      return;
> > > diff --git a/gcc/output.h b/gcc/output.h
> > > index
> 1f628ea2371aeca006d686e521a04d4f7ddb6e2d..101f4f8ed14808f37ab45
> 5e2cb9e68a3edd237f3 100644
> > > --- a/gcc/output.h
> > > +++ b/gcc/output.h
> > > @@ -79,7 +79,7 @@ extern rtx_insn *final_scan_insn (rtx_insn *, FILE *,
> int, int, int *);
> > >  extern rtx alter_subreg (rtx *, bool);
> > >
> > >  /* Print an operand using machine-dependent assembler syntax.  */
> > > -extern void output_operand (rtx, int);
> > > +extern void output_operand (rtx, const char * const *);
> > >
> > >  /* Report inconsistency between the assembler template and the
> operands.
> > >     In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
> > > diff --git a/gcc/target.def b/gcc/target.def
> > > index
> 206c94f8749ba8f242229d36da0049826c342502..793f64da9c0abb4ca470
> e6e9be0cd5eb1a859886 100644
> > > --- a/gcc/target.def
> > > +++ b/gcc/target.def
> > > @@ -892,7 +892,7 @@ return @code{true}.",
> > >  DEFHOOK_UNDOC
> > >  (print_operand,
> > >   "",
> > > - void, (FILE *file, rtx x, int code),
> > > + void, (FILE *file, rtx x, const char * const * p),
> > >   default_print_operand)
> > >
> > >  /* Emit a machine-specific memory address.  */
> > > diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
> > > index
> 5f1eac75122c9cc945012a02426784f6c2584328..63cefae50f8854992b3fb7
> d5ad8a32cf9511208a 100644
> > > --- a/gcc/targhooks.cc
> > > +++ b/gcc/targhooks.cc
> > > @@ -390,7 +390,7 @@ hook_callee_copies_named (cumulative_args_t,
> const function_arg_info &arg)
> > >
> > >  void
> > >  default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x
> ATTRIBUTE_UNUSED,
> > > -		       int code ATTRIBUTE_UNUSED)
> > > +		       const char * const *p ATTRIBUTE_UNUSED)
> > >  {
> > >  #ifdef PRINT_OPERAND
> > >    PRINT_OPERAND (stream, x, code);
> > > diff --git a/gcc/targhooks.h b/gcc/targhooks.h
> > > index
> 9582233e69fee1b56ab9d2f2573707621f9837ff..3031e08e84e7f1401d0fd
> 08bf8e16c37f78c98c9 100644
> > > --- a/gcc/targhooks.h
> > > +++ b/gcc/targhooks.h
> > > @@ -74,7 +74,7 @@ extern bool
> hook_pass_by_reference_must_pass_in_stack
> > >  extern bool hook_callee_copies_named
> > >    (cumulative_args_t ca, const function_arg_info &);
> > >
> > > -extern void default_print_operand (FILE *, rtx, int);
> > > +extern void default_print_operand (FILE *, rtx, const char * const *);
> > >  extern void default_print_operand_address (FILE *, machine_mode, rtx);
> > >  extern bool default_print_operand_punct_valid_p (unsigned char);
> > >  extern tree default_mangle_assembler_name (const char *);
> > >
> > >
> >
> >
> 
> --
> Richard Biener <rguenther@suse.de>
> SUSE Software Solutions Germany GmbH,
> Frankenstrasse 146, 90461 Nuernberg, Germany;
> GF: Jochen Jaser, Andrew McDonald, Werner Knoblich; (HRB 36809, AG
> Nuernberg)
  

On 08/04/2026 13:17, Tamar Christina wrote:
>> -----Original Message-----
>> From: Richard Biener <rguenther@suse.de>
>> Sent: 08 April 2026 13:10
>> To: Richard Earnshaw <Richard.Earnshaw@arm.com>
>> Cc: Tamar Christina <Tamar.Christina@arm.com>; gcc-patches@gcc.gnu.org;
>> nd <nd@arm.com>; jeffreyalaw@gmail.com; rdapp.gcc@gmail.com;
>> ktkachov@nvidia.com
>> Subject: Re: [PATCH 1/2][RFC][GCC 17][middle-end: Supporting multi
>> character string formatters
>>
>> On Wed, 8 Apr 2026, Richard Earnshaw (foss) wrote:
>>
>>> On 08/04/2026 09:18, Tamar Christina wrote:
>>>> Today asm print operands are required to be single characters.  This means
>> we're
>>>> quite limited in the number of them we can have and they are threated as
>> white
>>>> gold in many backends.
>>>>
>>>> This causes us to have to do some hack solutions in the backends for
>> instance to
>>>> support some SME operations just to avoid new print operands.
>>>>
>>>> This patch extends the parsers to support multiple token operands and
>> extends
>>>> the print_operand target hook to pass a pointer to the buffer being read so
>> the
>>>> backend can consume as many tokens as it needs.
>>>>
>>>> As a consequence backends are completely free to choose how their multi
>> letter
>>>> operands look like.
>>>>
>>>> There will need to be a mechanical change in all targets doing
>>>>
>>>> int code = p ? (unsigned char)**p : 0;
>>>>
>>>> to support this new interface.
>>>>
>>>> There is one restriction in that whatever the backends choose should not
>> overlap
>>>> with assembler dialect support.  This means that %{, &|,  %} are reserved.
>>>>
>>>> I am wondering however if there is apetite to try to see if we can
>> standardise
>>>> on a syntax for multi character operands or whether we shouldn't try.
>>>>
>>>> One possible way is to do what we do for constraints, where you specify a
>> letter
>>>> to start the multi letter parsing and a fixed number of character to parse.
>>>>
>>>> However this is annoying as it still makes us make cryptic names.
>>>>
>>>> In the AArch64 example patch I chose %[..] so e.g. %[SME_VC]0 but I don't
>> quite
>>>> like it. I could do instead %SME_VC:0? i.e. if the character following the
>>>> current one isn't a digit, consume until a : is found.
>>>>
>>>> Bootstrapped Regtested on aarch64-none-linux-gnu and no issues.
>>>>
>>>
>>> This would be a nice improvement.
>>>
>>> We currently have an int for the code, but only use a limited set of ascii
>> values with that.  Did you consider having a mapping function that could read
>> the extended formats and convert it to an int code for the extended values?
>> That would mean you wouldn't need to touch backends that haven't added
>> the parsing hook and would provide separation between reading a string code
>> and the backend processing of the value: the default hook would simply read a
>> char as before.
>>>
>>> Something like:
>>>  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned
>> char) *p))
>>> -	  output_operand (NULL_RTX, *p++);
>>> +         output_operand (NULL_RTX,
>> targetm.asm_out.print_operand_punct_code (&p);
>>
>> Or add &p as extra arg to the valid_p hook.  Or make
>> targetm.asm_out.print_operand_punct_code return single-char code as
>> well and hopefully reserved -1 or 0 as error.
>>
>> Richard.
> 
> I haven't considered this as I wanted to get some more descriptive names.
> The numerical value could work, but that's even harder to remember though.
> 

enum operand_x_codes
{
  SME_VC = 255,
  ...
}

...
switch (code)
{
  case 'a':
    ...
  case SME_VC:
    ...
}

Now all your punct_code function does is map the user-space string to the enumeration value.  We store them in ints so there's no representational issue.

R.


> And this would escape into inline asm a user could write.
> 
> In particular something like %40 is hard to parse. Is this %4 on operand 0, or code 40?
> 
> It would need a larger change to the parser, because it atm unconditionally consumes
> numerical operands before calling the target hook. i.e. %0 is consumed and just 0 passed
> to the backend as a char.
> 
> But it's certainly possible, but how do we then deal with the ambiguity? (I still really want
> more human friendly operands if possible though).

The intent was not to change the string side of this, just the internal handling so that we don't need to make major changes to the internal APIs.

R.

> 
> Thanks,
> Tamar
> 
>>
>>>         else
>>> ...
>>>
>>> Any code above, say, 255 could be used by a backend.
>>>
>>> What's more, most existing code that passes a hard-coded letter wouldn't
>> need changing at all.
>>>
>>> R.
>>>
>>>> Thoughts?
>>>>
>>>> Thanks,
>>>> Tamar
>>>>
>>>> gcc/ChangeLog:
>>>>
>>>> 	* target.def (print_operand): Modify with new pointer.
>>>> 	* targhooks.cc (default_print_operand): Update using pointer.
>>>> 	* targhooks.h (default_print_operand): Likewise.
>>>> 	* config/aarch64/aarch64.cc (aarch64_print_operand): Update
>>>> 	* final.cc (output_asm_insn): Update to new target hook format.
>>>> 	(output_operand): Likewise.
>>>> 	* output.h (output_operand): Likewise.
>>>>
>>>> ---
>>>> diff --git a/gcc/config/aarch64/aarch64.cc
>> b/gcc/config/aarch64/aarch64.cc
>>>> index
>> 1902a4ee9fa34a1f00e654760d0759af1d6cf432..1bf54641f581e90bb629d
>> 2fcd2f0d32a2c9474f9 100644
>>>> --- a/gcc/config/aarch64/aarch64.cc
>>>> +++ b/gcc/config/aarch64/aarch64.cc
>>>> @@ -13009,9 +13009,10 @@ sizetochar (int size)
>>>>       'z':		Output address of a typical LDP or STP.  */
>>>>
>>>>  static void
>>>> -aarch64_print_operand (FILE *f, rtx x, int code)
>>>> +aarch64_print_operand (FILE *f, rtx x, const char * const *p)
>>>>  {
>>>>    rtx elt;
>>>> +  int code = p ? (unsigned char)**p : 0;
>>>>    switch (code)
>>>>      {
>>>>      case 'c':
>>>> diff --git a/gcc/final.cc b/gcc/final.cc
>>>> index
>> b5e8c6e2efde01417370e7dea5456ba108b866ed..fcb8877f8814c4594f3a4
>> ddc0da03e631653caf4 100644
>>>> --- a/gcc/final.cc
>>>> +++ b/gcc/final.cc
>>>> @@ -3508,6 +3508,7 @@ output_asm_insn (const char *templ, rtx
>> *operands)
>>>>  	   the TARGET_PRINT_OPERAND hook can define them.  */
>>>>  	else if (ISALPHA (*p))
>>>>  	  {
>>>> +	    const char *p_init = p;
>>>>  	    int letter = *p++;
>>>>  	    unsigned long opnum;
>>>>  	    char *endptr;
>>>> @@ -3535,7 +3536,7 @@ output_asm_insn (const char *templ, rtx
>> *operands)
>>>>  		if (letter2 == 'c' || CONSTANT_ADDRESS_P
>> (operands[opnum]))
>>>>  		  output_addr_const (asm_out_file, operands[opnum]);
>>>>  		else
>>>> -		  output_operand (operands[opnum], 'c');
>>>> +		  output_operand (operands[opnum], &p_init);
>>>>  	      }
>>>>  	    else if (letter == 'n')
>>>>  	      {
>>>> @@ -3549,7 +3550,7 @@ output_asm_insn (const char *templ, rtx
>> *operands)
>>>>  		  }
>>>>  	      }
>>>>  	    else
>>>> -	      output_operand (operands[opnum], letter);
>>>> +	      output_operand (operands[opnum], &p_init);
>>>>
>>>>  	    if (!opoutput[opnum])
>>>>  	      oporder[ops++] = opnum;
>>>> @@ -3585,7 +3586,10 @@ output_asm_insn (const char *templ, rtx
>> *operands)
>>>>  	   punctuation character alone, with no operand.  The
>>>>  	   TARGET_PRINT_OPERAND hook decides what is actually done.  */
>>>>  	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned
>> char) *p))
>>>> -	  output_operand (NULL_RTX, *p++);
>>>> +	  {
>>>> +	    const char *ptr = p++;
>>>> +	    output_operand (NULL_RTX, &ptr);
>>>> +	  }
>>>>  	else
>>>>  	  output_operand_lossage ("invalid %%-code");
>>>>  	break;
>>>> @@ -3651,7 +3655,7 @@ mark_symbol_refs_as_used (rtx x)
>>>>     by TARGET_PRINT_OPERAND.  */
>>>>
>>>>  void
>>>> -output_operand (rtx x, int code ATTRIBUTE_UNUSED)
>>>> +output_operand (rtx x, const char * const *p ATTRIBUTE_UNUSED)
>>>>  {
>>>>    if (x && GET_CODE (x) == SUBREG)
>>>>      x = alter_subreg (&x, true);
>>>> @@ -3660,7 +3664,7 @@ output_operand (rtx x, int code
>> ATTRIBUTE_UNUSED)
>>>>    if (!targetm.no_register_allocation)
>>>>      gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
>>>>
>>>> -  targetm.asm_out.print_operand (asm_out_file, x, code);
>>>> +  targetm.asm_out.print_operand (asm_out_file, x, p);
>>>>
>>>>    if (x == NULL_RTX)
>>>>      return;
>>>> diff --git a/gcc/output.h b/gcc/output.h
>>>> index
>> 1f628ea2371aeca006d686e521a04d4f7ddb6e2d..101f4f8ed14808f37ab45
>> 5e2cb9e68a3edd237f3 100644
>>>> --- a/gcc/output.h
>>>> +++ b/gcc/output.h
>>>> @@ -79,7 +79,7 @@ extern rtx_insn *final_scan_insn (rtx_insn *, FILE *,
>> int, int, int *);
>>>>  extern rtx alter_subreg (rtx *, bool);
>>>>
>>>>  /* Print an operand using machine-dependent assembler syntax.  */
>>>> -extern void output_operand (rtx, int);
>>>> +extern void output_operand (rtx, const char * const *);
>>>>
>>>>  /* Report inconsistency between the assembler template and the
>> operands.
>>>>     In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
>>>> diff --git a/gcc/target.def b/gcc/target.def
>>>> index
>> 206c94f8749ba8f242229d36da0049826c342502..793f64da9c0abb4ca470
>> e6e9be0cd5eb1a859886 100644
>>>> --- a/gcc/target.def
>>>> +++ b/gcc/target.def
>>>> @@ -892,7 +892,7 @@ return @code{true}.",
>>>>  DEFHOOK_UNDOC
>>>>  (print_operand,
>>>>   "",
>>>> - void, (FILE *file, rtx x, int code),
>>>> + void, (FILE *file, rtx x, const char * const * p),
>>>>   default_print_operand)
>>>>
>>>>  /* Emit a machine-specific memory address.  */
>>>> diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
>>>> index
>> 5f1eac75122c9cc945012a02426784f6c2584328..63cefae50f8854992b3fb7
>> d5ad8a32cf9511208a 100644
>>>> --- a/gcc/targhooks.cc
>>>> +++ b/gcc/targhooks.cc
>>>> @@ -390,7 +390,7 @@ hook_callee_copies_named (cumulative_args_t,
>> const function_arg_info &arg)
>>>>
>>>>  void
>>>>  default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x
>> ATTRIBUTE_UNUSED,
>>>> -		       int code ATTRIBUTE_UNUSED)
>>>> +		       const char * const *p ATTRIBUTE_UNUSED)
>>>>  {
>>>>  #ifdef PRINT_OPERAND
>>>>    PRINT_OPERAND (stream, x, code);
>>>> diff --git a/gcc/targhooks.h b/gcc/targhooks.h
>>>> index
>> 9582233e69fee1b56ab9d2f2573707621f9837ff..3031e08e84e7f1401d0fd
>> 08bf8e16c37f78c98c9 100644
>>>> --- a/gcc/targhooks.h
>>>> +++ b/gcc/targhooks.h
>>>> @@ -74,7 +74,7 @@ extern bool
>> hook_pass_by_reference_must_pass_in_stack
>>>>  extern bool hook_callee_copies_named
>>>>    (cumulative_args_t ca, const function_arg_info &);
>>>>
>>>> -extern void default_print_operand (FILE *, rtx, int);
>>>> +extern void default_print_operand (FILE *, rtx, const char * const *);
>>>>  extern void default_print_operand_address (FILE *, machine_mode, rtx);
>>>>  extern bool default_print_operand_punct_valid_p (unsigned char);
>>>>  extern tree default_mangle_assembler_name (const char *);
>>>>
>>>>
>>>
>>>
>>
>> --
>> Richard Biener <rguenther@suse.de>
>> SUSE Software Solutions Germany GmbH,
>> Frankenstrasse 146, 90461 Nuernberg, Germany;
>> GF: Jochen Jaser, Andrew McDonald, Werner Knoblich; (HRB 36809, AG
>> Nuernberg)