agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation 112+ messages / 1 participants [nested] [flat]
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
* [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation @ 2026-06-12 00:15 Henson Choi <[email protected]> 0 siblings, 0 replies; 112+ messages in thread From: Henson Choi @ 2026-06-12 00:15 UTC (permalink / raw) The meson build passes c_args verbatim to the clang command that emits the JIT bitcode. Under -fsanitize=address the instrumentation ends up in the bitcode and breaks the JIT: any JIT-compiled query crashes the backend with SIGILL. The autoconf build is unaffected, as it builds BITCODE_CFLAGS from a whitelist that never includes CFLAGS. Filter sanitizer flags out of c_args during bitcode generation. Author: Matheus Alcantara <[email protected]> Reviewer: Henson Choi <[email protected]> --- src/backend/jit/llvm/meson.build | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/backend/jit/llvm/meson.build b/src/backend/jit/llvm/meson.build index 7df8453ad6f..1ebee3bdcaf 100644 --- a/src/backend/jit/llvm/meson.build +++ b/src/backend/jit/llvm/meson.build @@ -61,7 +61,23 @@ endif # XXX: Need to determine proper version of the function cflags for clang bitcode_cflags = ['-fno-strict-aliasing', '-fwrapv'] -bitcode_cflags += get_option('c_args') + +# Sanitizer instrumentation in the JIT bitcode corrupts the JIT code +# generator: JIT-compiled queries crash with SIGILL. Strip sanitizer flags +# from c_args during bitcode generation, and warn when we do, since the +# JIT-compiled code then runs without sanitizer coverage. +bitcode_sanitize_stripped = false +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true +foreach cflag : get_option('c_args') + if cflag.contains('sanitize') + bitcode_sanitize_stripped = true + else + bitcode_cflags += cflag + endif +endforeach +if bitcode_sanitize_stripped + warning('stripping sanitizer flags from LLVM JIT bitcode; JIT-compiled code will not be instrumented') +endif + bitcode_cflags += cppflags # XXX: Worth improving on the logic to find directories here -- 2.47.3 ---- v2-0002-meson-strip-sanitizer.patch ---- Regards, -- Tatsuo Ishii SRA OSS K.K. English: http://www.sraoss.co.jp/index_en/ Japanese:http://www.sraoss.co.jp ^ permalink raw reply [nested|flat] 112+ messages in thread
end of thread, other threads:[~2026-06-12 00:15 UTC | newest] Thread overview: 112+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]> 2026-06-12 00:15 [PATCH v2 2/3] Exclude sanitizer flags from LLVM JIT bitcode generation Henson Choi <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox