agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v1 3/4] autovac: combine reloptions correctly 249+ messages / 2 participants [nested] [flat]
* [PATCH v1 3/4] autovac: combine reloptions correctly @ 2025-06-23 20:16 Nathan Bossart <nathan@postgresql.org> 0 siblings, 0 replies; 249+ messages in thread From: Nathan Bossart @ 2025-06-23 20:16 UTC (permalink / raw) --- src/backend/postmaster/autovacuum.c | 85 +++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 3bedca971ff..0d1f4e38b58 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -1873,6 +1873,73 @@ get_database_list(void) return dblist; } +static void +combine_relopts(StdRdOptions *toast_opts, const StdRdOptions *main_opts) +{ + AutoVacOpts *toast_avopts = &toast_opts->autovacuum; + const AutoVacOpts *main_avopts = &main_opts->autovacuum; + + /* XXX: need isset_offset to combine "enabled" */ + + if (toast_avopts->vacuum_threshold == -1) + toast_avopts->vacuum_threshold = main_avopts->vacuum_threshold; + + if (toast_avopts->vacuum_max_threshold == -2) + toast_avopts->vacuum_max_threshold = main_avopts->vacuum_max_threshold; + + if (toast_avopts->vacuum_ins_threshold == -2) + toast_avopts->vacuum_ins_threshold = main_avopts->vacuum_ins_threshold; + + if (toast_avopts->analyze_threshold == -1) + toast_avopts->analyze_threshold = main_avopts->analyze_threshold; + + if (toast_avopts->vacuum_cost_limit == -1) + toast_avopts->vacuum_cost_limit = main_avopts->vacuum_cost_limit; + + if (toast_avopts->freeze_min_age == -1) + toast_avopts->freeze_min_age = main_avopts->freeze_min_age; + + if (toast_avopts->freeze_max_age == -1) + toast_avopts->freeze_max_age = main_avopts->freeze_max_age; + + if (toast_avopts->freeze_table_age == -1) + toast_avopts->freeze_table_age = main_avopts->freeze_table_age; + + if (toast_avopts->multixact_freeze_min_age == -1) + toast_avopts->multixact_freeze_min_age = main_avopts->multixact_freeze_min_age; + + if (toast_avopts->multixact_freeze_max_age == -1) + toast_avopts->multixact_freeze_max_age = main_avopts->multixact_freeze_max_age; + + if (toast_avopts->multixact_freeze_table_age == -1) + toast_avopts->multixact_freeze_table_age = main_avopts->multixact_freeze_table_age; + + /* XXX: need isset_offset for log_min_duration */ + + if (toast_avopts->vacuum_cost_delay == -1) + toast_avopts->vacuum_cost_delay = main_avopts->vacuum_cost_delay; + + if (toast_avopts->vacuum_scale_factor == -1) + toast_avopts->vacuum_scale_factor = main_avopts->vacuum_scale_factor; + + if (toast_avopts->vacuum_ins_scale_factor == -1) + toast_avopts->vacuum_ins_scale_factor = main_avopts->vacuum_ins_scale_factor; + + if (toast_avopts->analyze_scale_factor == -1) + toast_avopts->analyze_scale_factor = main_avopts->analyze_scale_factor; + + /* XXX: need isset_offset for vacuum_index_cleanup */ + + if (!toast_opts->vacuum_truncate_set && main_opts->vacuum_truncate_set) + { + toast_opts->vacuum_truncate = main_opts->vacuum_truncate; + toast_opts->vacuum_truncate_set = true; + } + + if (toast_opts->vacuum_max_eager_freeze_failure_rate == -1) + toast_opts->vacuum_max_eager_freeze_failure_rate = main_opts->vacuum_max_eager_freeze_failure_rate; +} + /* * Process a database table-by-table * @@ -2113,7 +2180,16 @@ do_autovacuum(void) */ relopts = (StdRdOptions *) extractRelOptions(tuple, pg_class_desc, NULL); if (relopts) + { + av_relation *hentry; + bool found; + free_relopts = true; + + hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found); + if (found && hentry->ar_hasrelopts) + combine_relopts(relopts, &hentry->ar_reloptions); + } else { av_relation *hentry; @@ -2733,7 +2809,16 @@ table_recheck_autovac(Oid relid, HTAB *table_toast_map, */ relopts = (StdRdOptions *) extractRelOptions(classTup, pg_class_desc, NULL); if (relopts) + { + av_relation *hentry; + bool found; + free_relopts = true; + + hentry = hash_search(table_toast_map, &relid, HASH_FIND, &found); + if (found && hentry->ar_hasrelopts) + combine_relopts(relopts, &hentry->ar_reloptions); + } else if (classForm->relkind == RELKIND_TOASTVALUE && table_toast_map != NULL) { -- 2.39.5 (Apple Git-154) --QWBYbd5Ar5k8NvSv Content-Type: text/plain; charset=us-ascii Content-Disposition: attachment; filename=v1-0004-combine-relopts-correctly-for-VACUUM-commands.patch ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <assam258@gmail.com> 0 siblings, 0 replies; 249+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <matheusssilv97@gmail.com> Reviewer: Henson Choi <assam258@gmail.com> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 249+ messages in thread
end of thread, other threads:[~2026-06-12 00:15 UTC | newest] Thread overview: 249+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2025-06-23 20:16 [PATCH v1 3/4] autovac: combine reloptions correctly Nathan Bossart <nathan@postgresql.org> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <assam258@gmail.com>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox