[ruby-core:110147] [Ruby master Bug#19028] GCC12 Introduces new warn flags `-Wuse-after-free`

["eightbitraptor (Matthew Valentine-House)" <noreply@ruby-lang.org>]

Issue #19028 has been updated by eightbitraptor (Matthew Valentine-House).


nobu (Nobuyoshi Nakada) wrote in #note-4:
> GCC 12 on GitHub Actions doesn’t show that warning.
> https://github.com/ruby/ruby/actions/runs/3146751201/jobs/5115549022#step:13:130
> 
> I’m not sure what differs.

mame (Yusuke Endoh) wrote in #note-5:
> I am not able to repro with `gcc-12 (Ubuntu 12.1.0-2ubuntu1~22.04) 12.1.0` and x86_64-linux.

Apologies. I had a look into this and realised that this warning only occurs when `optflags=-O0`.

With `O0` I can successfully repro this on:

* `gcc version 12.2.1 20220819 (Red Hat 12.2.1-2) (GCC)` on `Fedora 36` - where I originally saw this warning.
* `gcc version 12.1.0 (Ubuntu 12.1.0-2ubuntu1~22.04)`
* `gcc version 12.2.0 (Ubuntu 12.2.0-3ubuntu1)` on `Ubuntu Kinetic Kudu (development branch) 22.10`

I don't know if we should justify lowering a warning level globally for a warning that only appears in unoptimized code - what do you think?


----------------------------------------
Bug #19028: GCC12 Introduces new warn flags `-Wuse-after-free`
https://bugs.ruby-lang.org/issues/19028#change-99404

* Author: eightbitraptor (Matthew Valentine-House)
* Status: Open
* Priority: Normal
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
[GCC 12 introduced a new warning flag `-Wuse-after-free`](https://github.com/gcc-mirror/gcc/commit/671a283636de75f7ed638ee6b01ed2d44361b8b6) which attempts to warn about uses of pointers to dynamically allocated objects that have been rendered indeterminate by a call to a deallocation function

Details of the levels are in [the C++ Dialect Options section of the GCC documentation](https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html).

Compiling with `-Wall` uses the default setting of `2` for this flag. Which warns on the `TRY_WITH_GC` macro defined in `gc.c`

```
gc.c: In function ‘objspace_xrealloc’:                                                                             
gc.c:12213:33: warning: pointer ‘ptr’ may be used after ‘realloc’ [-Wuse-after-free]                               
12213 |     TRY_WITH_GC(new_size, mem = realloc(ptr, new_size));                                                   
      |                                 ^~~~~~~~~~~~~~~~~~~~~~                                                     
gc.c:12123:19: note: in definition of macro ‘TRY_WITH_GC’                                                          
12123 |         else if ((expr)) {                                   \                                             
      |                   ^~~~                                                                                     
In file included from ./include/ruby/defines.h:72,                                                                 
                 from ./include/ruby/ruby.h:25,                                                                    
                 from constant.h:13,                                                                               
                 from gc.c:97:                                                                                     
gc.c:12213:33: note: call to ‘realloc’ here                                                                        
12213 |     TRY_WITH_GC(new_size, mem = realloc(ptr, new_size));                                                   
      |                                 ^~~~~~~~~~~~~~~~~~~~~~                                                                                                                                                                        
./include/ruby/backward/2/assume.h:43:46: note: in definition of macro ‘RB_LIKELY’                                 
   43 | # define RB_LIKELY(x)   (__builtin_expect(!!(x), 1))                                                       
      |                                              ^                                                             
gc.c:12116:13: note: in expansion of macro ‘LIKELY’ 
12116 |         if (LIKELY((expr))) {                                \                                             
      |             ^~~~~~                       
gc.c:12213:5: note: in expansion of macro ‘TRY_WITH_GC’
12213 |     TRY_WITH_GC(new_size, mem = realloc(ptr, new_size));                                                   
      |     ^~~~~~~~~~~            
```

My understanding is that if `realloc` returns a null pointer then the memory requested for reallocation is guaranteed to not be touched (according to [the Open Group](https://pubs.opengroup.org/onlinepubs/9699919799/functions/realloc.html) - thank you @nobu for bringing this to my attention).

Given that this is a new warning, my proposed solution is to lower the level down to the base level `1`. This will only warn on unconditional calls to deallocation functions or successful calls to realloc.

I've opened a PR that sets `-Wuse-after-free=1` only for GCC versions > 11. An alternative approach might be to use `#pragma GCC diagnostic` to suppress this just for GCC but I opted for what I thought was the easiest fix to start with.

[Github PR #6465](https://github.com/ruby/ruby/pull/6465)



-- 
https://bugs.ruby-lang.org/