libbpf: add GCC support for bpf_tail_call_static
PATCH v2 1/1 libbpf: add GCC support for bpf_tail_call_static
The bpf_tail_call_static function is currently not defined unless using clang >= 8.
To support bpf_tail_call_static on GCC we can check if __clang__ is not defined to enable bpf_tail_call_static.
We need to use GCC assembly syntax when the compiler does not define __clang__ as LLVM inline assembly is not fully compatible with GCC.
---
Changes v1 -> v2:
- drop __BPF__ check as GCC now defines __bpf__
--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
tools/lib/bpf/bpf_helpers.h +13 -6
@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {
@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key
@@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asmvolatile ("r1 = %[ctx]\n\t" + asmvolatile ( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endif"call 12" :: [ctx]"r" (ctx), [map]"r" (map), [slot]"i" (slot) :"r0" ,"r1" ,"r2" ,"r3" ,"r4" ,"r5" );
Signature · 1 line
2.34.1
This patch was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Hello:
This patch was applied to bpf/bpf-next.git (master) by Daniel Borkmann <[email protected]>:
Quoted 10 lines · On Mon, 29 Aug 2022 15:05:46 -0600 you wrote:
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.[...]
Here is the summary with links:
- [v2] libbpf: add GCC support for bpf_tail_call_static
https://git.kernel.org/bpf/bpf-next/c/14e5ce79943a
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"
tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endif
Hey James,
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as r1 = X in GCC or Clang-specific ways is a huge burden.
As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplate
Quoted 22 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 71 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 9 lines
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplate
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
Quoted 22 lines
Quoted 22 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 84 lines · Andrii Nakryiko
Quoted 71 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 9 lines
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplate
Quoted 5 lines
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
I mean it's unclear if it's a generic assembly template format difference that applies to all targets or one that's BPF target specific.
Anyways for now I sent a new patch so that bpf_tail_call_static is defined on non-clang compilers so that it will work when GCC-BPF supports the existing asm format.
https://lore.kernel.org/bpf/[email protected]/
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 87 lines
Quoted 84 lines · Andrii Nakryiko
Quoted 80 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplate
Quoted 8 lines
Quoted 5 lines
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
I mean it's unclear if it's a generic assembly template format difference that applies to all targets or one that's BPF target specific.
It is certainly BPF specific.
I think that when I first wrote the BPF GNU toolchain port the assembly format used by LLVM was different than it is now: I certainly didn't invent the syntax the GNU assembler uses for BPF.
It seems LLVM settled with that C-like syntax for assembly instead, which is very unconventional.
Quoted 4 lines
Anyways for now I sent a new patch so that
bpf_tail_call_staticis defined on non-clang compilers so that it will work when GCC-BPF supports the existing asm format.
https://lore.kernel.org/bpf/[email protected]/
I don't think this patch makes much sense: these guards are designed to avoid compilers that do not support the inline assembly (as presumably happen with clang < 8) to choke on the header file. That's also the case of GCC BPF at the moment.
With this patch, people won't be currentty able to use bpf_helpers.h with GCC BPF even if they don't use bpf_tail_call_static.
Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
Quoted 22 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 111 lines · Jose E. Marchesi
Quoted 88 lines
Quoted 84 lines · Andrii Nakryiko
Quoted 80 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplateQuoted 8 lines
Quoted 5 lines
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
I mean it's unclear if it's a generic assembly template format difference that applies to all targets or one that's BPF target specific.
It is certainly BPF specific.
I think that when I first wrote the BPF GNU toolchain port the assembly format used by LLVM was different than it is now: I certainly didn't invent the syntax the GNU assembler uses for BPF.
It seems LLVM settled with that C-like syntax for assembly instead, which is very unconventional.
Quoted 4 lines
Anyways for now I sent a new patch so that
bpf_tail_call_staticis defined on non-clang compilers so that it will work when GCC-BPF supports the existing asm format.
https://lore.kernel.org/bpf/[email protected]/
Quoted 7 lines
I don't think this patch makes much sense: these guards are designed to avoid compilers that do not support the inline assembly (as presumably happen with clang < 8) to choke on the header file. That's also the case of GCC BPF at the moment.
With this patch, people won't be currentty able to use
bpf_helpers.hwith GCC BPF even if they don't usebpf_tail_call_static.
That doesn't seem to be an issue here, from what I can tell it's not a failure in the compiler but a failure in the assembler, so having bpf_tail_call_static unguarded in GCC doesn't break anything that isn't already broken.
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 119 lines
Quoted 116 lines · Jose E. Marchesi
Quoted 88 lines
Quoted 84 lines · Andrii Nakryiko
Quoted 80 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplateQuoted 8 lines
Quoted 5 lines
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
I mean it's unclear if it's a generic assembly template format difference that applies to all targets or one that's BPF target specific.
It is certainly BPF specific.
I think that when I first wrote the BPF GNU toolchain port the assembly format used by LLVM was different than it is now: I certainly didn't invent the syntax the GNU assembler uses for BPF.
It seems LLVM settled with that C-like syntax for assembly instead, which is very unconventional.
Quoted 4 lines
Anyways for now I sent a new patch so that
bpf_tail_call_staticis defined on non-clang compilers so that it will work when GCC-BPF supports the existing asm format.
https://lore.kernel.org/bpf/[email protected]/I don't think this patch makes much sense: these guards are designed to avoid compilers that do not support the inline assembly (as presumably happen with clang < 8) to choke on the header file. That's also the case of GCC BPF at the moment.
Quoted 7 lines
Quoted 2 lines
With this patch, people won't be currentty able to use
bpf_helpers.hwith GCC BPF even if they don't usebpf_tail_call_static.That doesn't seem to be an issue here, from what I can tell it's not a failure in the compiler but a failure in the assembler, so having
bpf_tail_call_staticunguarded in GCC doesn't break anything that isn't already broken.
IMO it makes it worse, because:
1) With your patch the error message will happen at assembly time (invalid syntax in the intermediate .s file mixed with valid syntax) pointing to a location in a temporary .S file. With the guards, you get an error at compile time instead, pointing to the undefined function in the C source. IMO it is much easier to figure out what is wrong in the second case than in the first.
2) If/when we support the C-like assembly syntax in GCC, you will want to guard the function anyway with a GCC_MAJOR > 12 (or whatever) very much like it is done with clang >= 8.
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
Quoted 23 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 128 lines · Jose E. Marchesi
Quoted 120 lines
Quoted 116 lines · Jose E. Marchesi
Quoted 88 lines
Quoted 84 lines · Andrii Nakryiko
Quoted 80 lines · James Hilliard
Quoted 68 lines · Andrii Nakryiko
Quoted 52 lines · James Hilliard
The
bpf_tail_call_staticfunction is currently not defined unless using clang >= 8.To support
bpf_tail_call_staticon GCC we can check if__clang__is not defined to enablebpf_tail_call_static.We need to use GCC assembly syntax when the compiler does not define
__clang__as LLVM inline assembly is not fully compatible with GCC.Signed-off-by James Hilliard <[email protected]>---
Changes v1 -> v2:
- drop__BPF__check as GCC now defines__bpf__--- tools/lib/bpf/bpf_helpers.h | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)tools/lib/bpf/bpf_helpers.h +5
-6@@ -131,7 +131,7 @@/* * Helper function to perform a tail call with a constant/immediate map slot. */ -#if __clang_major__ >=8 && defined(__bpf__) +#if (!defined(__clang__) || __clang_major__ >=8 ) && defined(__bpf__) static __always_inline voidbpf_tail_call_static (void *ctx,const void *map,const __u32 slot) {@@ -139,8 +139,8 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)__bpf_unreachable ();/* -* Provide a hard guarantee that LLVM won't optimize setting r2 (map -* pointer) and r3 (constant map index) from _different paths_ ending +* Provide a hard guarantee that the compiler won't optimize setting r2 +* (map pointer) and r3 (constant map index) from _different paths_ ending * up at the _same_ call insn as otherwise we won't be able to use the * jmpq/nopl retpoline-free patching by the x86-64 JIT in the kernel * given they mismatch. See also d2e4c1e6c294 ("bpf: Constant map key @@ -148,12 +148,19 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)* * Note on clobber list: we need to stay in-line with BPF calling * convention, so even if we don't end up using r0, r4, r5, we need -* to mark them as clobber so that LLVM doesn't end up using them -* before / after the call. +* to mark them as clobber so that the compiler doesn't end up using +* them before / after the call. */ - asm volatile("r1 = %[ctx]\n\t"tools/lib/bpf/bpf_helpers.h bpf_tail_call_static(void *ctx, const void *map, const __u32 slot) · line 163
Quoted 10 lines
tools/lib/bpf/bpf_helpers.h +8
-0+ asm volatile( +#ifdef __clang__ + "r1 = %[ctx]\n\t" "r2 = %[map]\n\t" "r3 = %[slot]\n\t" +#else + "mov %%r1,%[ctx]\n\t" + "mov %%r2,%[map]\n\t" + "mov %%r3,%[slot]\n\t" +#endifHey James,
Quoted 4 lines
I don't think it's a good idea to have a completely different BPF asm syntax in GCC-BPF vs what Clang is supporting. Note that Clang syntax is also what BPF users see in BPF verifier log and in llvm-objdump output, so that's what BPF users are familiar with.
Is the difference a BPF specific assembly format deviation or a generic deviation in assembler template syntax between GCC/llvm?
https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#AssemblerTemplateQuoted 8 lines
Quoted 5 lines
Sorry, I don't understand the question. I'm talking about the above snippet with "r1 = %[ctx]" vs "mov %%r1,%[ctx]". Seems like the rest stayed the same. So this would be a "BPF specific assembly format" case, right? I don't know what else could be different with GCC-BPF assembly.
I mean it's unclear if it's a generic assembly template format difference that applies to all targets or one that's BPF target specific.
It is certainly BPF specific.
I think that when I first wrote the BPF GNU toolchain port the assembly format used by LLVM was different than it is now: I certainly didn't invent the syntax the GNU assembler uses for BPF.
It seems LLVM settled with that C-like syntax for assembly instead, which is very unconventional.
Quoted 4 lines
Anyways for now I sent a new patch so that
bpf_tail_call_staticis defined on non-clang compilers so that it will work when GCC-BPF supports the existing asm format.
https://lore.kernel.org/bpf/[email protected]/I don't think this patch makes much sense: these guards are designed to avoid compilers that do not support the inline assembly (as presumably happen with clang < 8) to choke on the header file. That's also the case of GCC BPF at the moment.
Quoted 7 lines
Quoted 2 lines
With this patch, people won't be currentty able to use
bpf_helpers.hwith GCC BPF even if they don't usebpf_tail_call_static.That doesn't seem to be an issue here, from what I can tell it's not a failure in the compiler but a failure in the assembler, so having
bpf_tail_call_staticunguarded in GCC doesn't break anything that isn't already broken.
Quoted 8 lines
IMO it makes it worse, because:
1) With your patch the error message will happen at assembly time (invalid syntax in the intermediate .s file mixed with valid syntax) pointing to a location in a temporary .S file. With the guards, you get an error at compile time instead, pointing to the undefined function in the C source. IMO it is much easier to figure out what is wrong in the second case than in the first.
A compile time error may be somewhat misleading as one would suspect the issue is with a missing include or something along those lines, even though the issue is with the inline assembly.
Quoted 4 lines
2) If/when we support the C-like assembly syntax in GCC, you will want to guard the function anyway with a
GCC_MAJOR> 12 (or whatever) very much like it is done with clang >= 8.
Wouldn't we need to check the GAS version instead of the GCC version? AFAIU GAS version isn't known at compile time so a version check may not make sense here for GCC.
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
Quoted 24 lines
This will cause constant and unavoidable maintenance burden both for libraries like libbpf and end users and their BPF apps as well.
Given you are trying to make GCC-BPF part of the BPF ecosystem, please think about how to help the ecosystem, move it forward and unify it, not how to branch out and have Clang vs GCC differences everywhere. There is a lot of embedded BPF asm in production applications, having to write something as trivial as
r1 = Xin GCC or Clang-specific ways is a huge burden.As such, we've reverted your patch ([0]). Please add de facto BPF asm syntax support to GCC-BPF and this change won't be necessary.
Quoted 6 lines
tools/lib/bpf/bpf_helpers.h +0
-1"call 12" :: [ctx]"r"(ctx), [map]"r"(map), [slot]"i"(slot) : "r0", "r1", "r2", "r3", "r4", "r5"); --2.34.1
Quoted 2 lines · Jose E. Marchesi
2) If/when we support the C-like assembly syntax in GCC,
Thank you for considering supporting the standard BPF assembly syntax in GCC.
I agree that C-like asm looks unusual.
The main reason to pick that style was the ease of understanding and to avoid gnu vs intel asm order confusion.
We didn't want to deal with question whether 'mov r1, r2' means r1->r2 or r2->r1. The C style asm r1=r2 is unambiguous.