From: "nobu (Nobuyoshi Nakada)" Date: 2022-09-30T06:34:59+00:00 Subject: [ruby-core:110152] [Ruby master Bug#19028] GCC12 Introduces new warn flags `-Wuse-after-free` Issue #19028 has been updated by nobu (Nobuyoshi Nakada). I see, what about this? ```diff diff --git a/gc.c b/gc.c index ac5ed1e7cba..a22da5482be 100644 --- a/gc.c +++ b/gc.c @@ -12102,10 +12102,18 @@ objspace_malloc_fixup(rb_objspace_t *objspace, void *mem, size_t size) # define RB_BUG_INSTEAD_OF_RB_MEMERROR 0 #endif -#define GC_MEMERROR(...) \ +#define GC_MEMERROR(...) /* NORETURN */ \ ((RB_BUG_INSTEAD_OF_RB_MEMERROR+0) ? rb_bug("" __VA_ARGS__) : rb_memerror()) -#define TRY_WITH_GC(siz, expr) do { \ +#if RBIMPL_COMPILER_SINCE(GCC, 12, 0, 0) && !defined(__OPTIMIZE__) +# define DISABLE_GNUC_USE_AFTRE_FREE_WARNING() \ + RBIMPL_WARNING_IGNORED(-Wuse-after-free) +#else +# define DISABLE_GNUC_USE_AFTRE_FREE_WARNING() +#endif + +#define TRY_WITH_GC(siz, expr) (siz, expr, (void)0) +#define TRY_WITH_GC_WITHOUT_WARNING(siz, expr, warn2nd) do { \ const gc_profile_record_flag gpr = \ GPR_FLAG_FULL_MARK | \ GPR_FLAG_IMMEDIATE_MARK | \ @@ -12114,16 +12122,19 @@ objspace_malloc_fixup(rb_objspace_t *objspace, void *mem, size_t size) objspace_malloc_gc_stress(objspace); \ \ if (LIKELY((expr))) { \ - /* Success on 1st try */ \ + break; /* Success on 1st try */ \ } \ - else if (!garbage_collect_with_gvl(objspace, gpr)) { \ + if (!garbage_collect_with_gvl(objspace, gpr)) { \ /* @shyouhei thinks this doesn't happen */ \ GC_MEMERROR("TRY_WITH_GC: could not GC"); \ } \ - else if ((expr)) { \ - /* Success on 2nd try */ \ + RBIMPL_WARNING_PUSH(); \ + warn2nd; \ + if ((expr)) { \ + break; /* Success on 2nd try */ \ } \ - else { \ + RBIMPL_WARNING_POP(); \ + { \ GC_MEMERROR("TRY_WITH_GC: could not allocate:" \ "%"PRIdSIZE" bytes for %s", \ siz, # expr); \ @@ -12210,7 +12221,8 @@ objspace_xrealloc(rb_objspace_t *objspace, void *ptr, size_t new_size, size_t ol #endif old_size = objspace_malloc_size(objspace, ptr, old_size); - TRY_WITH_GC(new_size, mem = realloc(ptr, new_size)); + TRY_WITH_GC_WITHOUT_WARNING(new_size, mem = realloc(ptr, new_size), + DISABLE_GNUC_USE_AFTRE_FREE_WARNING()); new_size = objspace_malloc_size(objspace, mem, new_size); #if CALC_EXACT_MALLOC_SIZE ``` ---------------------------------------- Bug #19028: GCC12 Introduces new warn flags `-Wuse-after-free` https://bugs.ruby-lang.org/issues/19028#change-99409 * 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/ Unsubscribe: