[2/2] wcrtomb: Make behavior POSIX compliant

  The GNU implementation of wcrtomb assumes that there are at least
MB_CUR_MAX bytes available in the destination buffer passed to wcrtomb
as the first argument.  This is not compatible with the POSIX
definition, which only requires enough space for the input wide
character.

This does not break much in practice because when users supply buffers
smaller than MB_CUR_MAX (e.g. in ncurses), they compute and dynamically
allocate the buffer, which results in enough spare space (thanks to
usable_size in malloc and padding in alloca) that no actual buffer
overflow occurs.  However when the code is built with _FORTIFY_SOURCE,
it runs into the hard check against MB_CUR_MAX in __wcrtomb_chk and
hence fails.  It wasn't evident until now since dynamic allocations
would result in wcrtomb not being fortified but since _FORTIFY_SOURCE=3,
that limitation is gone, resulting in such code failing.

To fix this problem, introduce an internal buffer that is MB_LEN_MAX
long and use that to perform the conversion and then copy the resultant
bytes into the destination buffer.  Also move the fortification check
into the main implementation, which checks the result after conversion
and aborts if the resultant byte count is greater than the destination
buffer size.

One complication is that applications that assume the MB_CUR_MAX
limitation to be gone may not be able to run safely on older glibcs if
they use static destination buffers smaller than MB_CUR_MAX; dynamic
allocations will always have enough spare space that no actual overruns
will occur.  One alternative to fixing this is to bump symbol version to
prevent them from running on older glibcs but that seems too strict a
constraint.  Instead, since these users will only have made this
decision on reading the manual, I have put a note in the manual warning
them about the pitfalls of having static buffers smaller than
MB_CUR_MAX and running them on older glibc.

Benchmarking:

The wcrtomb microbenchmark shows significant increases in maximum
execution time for all locales, ranging from 10x for ar_SA.UTF-8 to
1.5x-2x for nearly everything else.  The mean execution time however saw
practically no impact, with some results even being quicker, indicating
that cache locality has a much bigger role in the overhead.

Given that the additional copy uses a temporary buffer inside wcrtomb,
it's likely that a hot path will end up putting that buffer (which is
responsible for the additional overhead) in a similar place on stack,
giving the necessary cache locality to negate the overhead.  However in
situations where wcrtomb ends up getting called at wildly different
spots on the call stack (or is on different call stacks, e.g. with
threads or different execution contexts) and is still a hotspot, the
performance lag will be visible.

Signed-off-by: Siddhesh Poyarekar <siddhesh@sourceware.org>
---
 debug/tst-fortify.c |  7 ++++++-
 debug/wcrtomb_chk.c |  8 ++------
 include/wchar.h     |  4 ++++
 manual/charset.texi | 10 +++++-----
 wcsmbs/wcrtomb.c    | 34 ++++++++++++++++++++++++++--------
 5 files changed, 43 insertions(+), 20 deletions(-)
  

On 5/5/22 11:43, Siddhesh Poyarekar wrote:
> +      else if (__glibc_unlikely (result > 1))
> +	*((uint16_t *) s) = *((uint16_t *) buf);

Shouldn't this be protected by "#if _STRING_ARCH_unaligned"? Also, 
unnecessary parens.

But better yet, just call memcpy as the compiler will figure it out; see 
below.


> -    result = data.__outbuf - (unsigned char *) s;
> +    result = data.__outbuf - (unsigned char *) buf;
>    else
>      {
>        result = (size_t) -1;
>        __set_errno (EILSEQ);
>      }
>  
> +  if (result != (size_t) -1 && s != NULL)

The 'result != (size_t) -1' can be omitted if you move that 'if' into 
the previous if's then-part.


> +  data.__outbufend = (unsigned char *) buf + MB_CUR_MAX;

This'd be a bit faster (and less confusing) if we replace 'MB_CUR_MAX' 
with 'sizeof buf'.


> +      if (__glibc_unlikely (result > 2))
> +	memcpy (s, buf, result);
> +      else if (__glibc_unlikely (result > 1))
> +	*((uint16_t *) s) = *((uint16_t *) buf);
> +      else
> +	*s = *buf;

If the likely path is result == 1, shouldn't that be checked first? 
Something like this:

      if (__glibc_likely (result < 2))
        *s = *buf;
      else if (__glibc_likely (result == 2))
        memcpy (s, buf, result); /* Help the compiler.  */
      else
        memcpy (s, buf, result);
  

On 06/05/2022 06:25, Paul Eggert wrote:
> On 5/5/22 11:43, Siddhesh Poyarekar wrote:
>> +      else if (__glibc_unlikely (result > 1))
>> +    *((uint16_t *) s) = *((uint16_t *) buf);
> 
> Shouldn't this be protected by "#if _STRING_ARCH_unaligned"? Also, unnecessary parens.

I think this is an aliasing violation and most likely will fault on architectures
that do not support unaligned access (such as sparc and some arm environments).


> 
> But better yet, just call memcpy as the compiler will figure it out; see below.
> 
> 
>> -    result = data.__outbuf - (unsigned char *) s;
>> +    result = data.__outbuf - (unsigned char *) buf;
>>    else
>>      {
>>        result = (size_t) -1;
>>        __set_errno (EILSEQ);
>>      }
>>  
>> +  if (result != (size_t) -1 && s != NULL)
> 
> The 'result != (size_t) -1' can be omitted if you move that 'if' into the previous if's then-part.
> 
> 
>> +  data.__outbufend = (unsigned char *) buf + MB_CUR_MAX;
> 
> This'd be a bit faster (and less confusing) if we replace 'MB_CUR_MAX' with 'sizeof buf'.
> 
> 
>> +      if (__glibc_unlikely (result > 2))
>> +    memcpy (s, buf, result);
>> +      else if (__glibc_unlikely (result > 1))
>> +    *((uint16_t *) s) = *((uint16_t *) buf);
>> +      else
>> +    *s = *buf;
> 
> If the likely path is result == 1, shouldn't that be checked first? Something like this:
> 
>      if (__glibc_likely (result < 2))
>        *s = *buf;
>      else if (__glibc_likely (result == 2))
>        memcpy (s, buf, result); /* Help the compiler.  */
>      else
>        memcpy (s, buf, result);
  

On 06/05/2022 19:10, Adhemerval Zanella via Libc-alpha wrote:
> 
> 
> On 06/05/2022 06:25, Paul Eggert wrote:
>> On 5/5/22 11:43, Siddhesh Poyarekar wrote:
>>> +      else if (__glibc_unlikely (result > 1))
>>> +    *((uint16_t *) s) = *((uint16_t *) buf);
>>
>> Shouldn't this be protected by "#if _STRING_ARCH_unaligned"? Also, unnecessary parens.
> 
> I think this is an aliasing violation and most likely will fault on architectures
> that do not support unaligned access (such as sparc and some arm environments).
> 

I've dropped this in v2 in favour of calling memcpy and rely on the 
compiler to inline the call.  I'll post as soon as `make check` is done.

Thanks,
Siddhesh