agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH v8a 04/14] ci: Store build/meson-logs and name "id: os" task 249+ messages / 2 participants [nested] [flat]
* [PATCH v8a 04/14] ci: Store build/meson-logs and name "id: os" task @ 2026-06-03 05:31 Andres Freund <andres@anarazel.de> 0 siblings, 0 replies; 249+ messages in thread From: Andres Freund @ 2026-06-03 05:31 UTC (permalink / raw) --- .github/workflows/pg-ci.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/pg-ci.yml b/.github/workflows/pg-ci.yml index 8594d540f6a..a4fd4f42a50 100644 --- a/.github/workflows/pg-ci.yml +++ b/.github/workflows/pg-ci.yml @@ -157,7 +157,8 @@ jobs: ulimit -a -H && ulimit -a -S env - - id: os + - name: Parse ci-os-only + id: os env: MSG: ${{ github.event.head_commit.message }} shell: bash @@ -328,6 +329,7 @@ jobs: **/*.diffs **/regress_log_* **/crashlog-*.txt + build/meson-logs/** if-no-files-found: ignore -- 2.54.0.380.gc69baaf57b --vphnza2cz5zw5t4a Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v8a-0005-ci-Use-mingw-pkgconf-instead-of-pkg-config-packa.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 -- 2026-06-03 05:31 [PATCH v8a 04/14] ci: Store build/meson-logs and name "id: os" task Andres Freund <andres@anarazel.de> 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