Sign extension ISA question
Subsystems (3)
Is there any semantic difference between the following two instructions?
{.opcode = BPF_ALU64 | BPF_MOV | BPF_K, .offset = 0, .imm = -1}
{.opcode = BPF_ALU64 | BPF_MOVSX | BPF_K, .offset = 32, .imm = -1}
Quoted 1 line
From my reading both of them treat imm as a signed 32-bit number and
sign-extend it to 64 bits.
Dave
Signature · 3 lines
Bpf mailing list [email protected] https://www.ietf.org/mailman/listinfo/bpf
(Resending since a spam filter seems to have blocked the first attempt.)
Is there any semantic difference between the following two instructions?
{.opcode = BPF_ALU64 | BPF_MOV | BPF_K, .offset = 0, .imm = -1}
{.opcode = BPF_ALU64 | BPF_MOVSX | BPF_K, .offset = 32, .imm = -1}
From my reading both of them treat imm as a signed 32-bit number and sign-extend it to 64 bits.
Dave
Yonghong Song
reviewerQuoted 5 lines · On 1/16/24 12:55 PM, [email protected] wrote:
(Resending since a spam filter seems to have blocked the first attempt.)
Is there any semantic difference between the following two instructions?
{.opcode =
BPF_ALU64|BPF_MOV|BPF_K, .offset = 0, .imm = -1}
This is supported. Sign extension of -1 will be put into ALU64 reg.
Quoted 2 lines
{.opcode =
BPF_ALU64|BPF_MOVSX|BPF_K, .offset = 32, .imm = -1}
This is not supported. BPF_MOVSX only supports register extension. We should make it clear in the doc.
Quoted 7 lines
From my reading both of them treat imm as a signed 32-bit number and
sign-extend it to 64 bits.Dave
Quoted 11 lines · Yonghong Song
Quoted 3 lines
Is there any semantic difference between the following two instructions?
{.opcode =
BPF_ALU64|BPF_MOV|BPF_K, .offset = 0, .imm = -1}This is supported. Sign extension of -1 will be put into ALU64 reg.
Quoted 2 lines
{.opcode =
BPF_ALU64|BPF_MOVSX|BPF_K, .offset = 32, .imm = -1}This is not supported.
BPF_MOVSXonly supports register extension. We should make it clear in the doc.
Is that limitation a Linux-specific implementation statement? (i.e., put into linux-notes.txt)
Or that the meaning is undefined for all runtimes and could be used for some other purpose in the future? (i.e., put into instruction-set.rst)
For now I'll interpret it as the latter.
Thanks,
Dave
Yonghong Song
reviewerQuoted 9 lines · On 1/16/24 5:56 PM, [email protected] wrote:
Quoted 8 lines · Yonghong Song
Quoted 3 lines
Is there any semantic difference between the following two instructions?
{.opcode =
BPF_ALU64|BPF_MOV|BPF_K, .offset = 0, .imm = -1}This is supported. Sign extension of -1 will be put into ALU64 reg.
Quoted 1 line
{.opcode =
BPF_ALU64|BPF_MOVSX|BPF_K, .offset = 32, .imm = -1}This is not supported.
BPF_MOVSXonly supports register extension. We should make it clear in the doc.
Quoted 7 lines
Is that limitation a Linux-specific implementation statement? (i.e., put into linux-notes.txt)
Or that the meaning is undefined for all runtimes and could be used for some other purpose in the future? (i.e., put into
instruction-set.rst)For now I'll interpret it as the latter.
You are right. The
{.opcode = BPF_ALU64 | BPF_MOVSX | BPF_K, .offset = 32, .imm = -1}
is not supported by bpf ISA. Currently, it will be an illegal encoding from kernel perspective.
Jump instructions clarification
Hi Yonghong,
The MOVSX clarification is now merged, but I just found another similar question for you regarding jump instructions.
For BPF_CALL (same question for src=0, src=1, and src=2),
are both BPF_JMP and BPF_JMP32 legal? If so, is there a semantic difference? If not, then again I think the doc needs clarification.
BPF_JA's use of imm already has a note that it's BPF_JMP32 class only, but what about BPF_CALL's use of imm?
Similarly about comparisons like BPF_JEQ etc when BPF_K is set.
E.g., is BPF_JEQ | BPF_K | BPF_JMP permitted? The document currently has no restriction against it, but if it's permitted, the meaning is not explained.
Dave
Yonghong Song
reviewerRe: Jump instructions clarification
Quoted 8 lines · On 1/23/24 6:07 PM, [email protected] wrote:
Hi Yonghong,
The MOVSX clarification is now merged, but I just found another similar question for you regarding jump instructions.
For
BPF_CALL(same question for src=0, src=1, and src=2),
are bothBPF_JMPandBPF_JMP32legal? If so, is there a semantic difference? If not, then again I think the doc needs clarification.
BPF_CALL with BPF_JMP32 is illegal. This is true for src=0/1/2.
Quoted 3 lines
BPF_JA's use of imm already has a note that it's
BPF_JMP32class only, but what about BPF_CALL's use of imm?
The imm field of BPF_CALL insn is used for call target.
Quoted 4 lines
Similarly about comparisons like
BPF_JEQetc whenBPF_Kis set.
E.g., isBPF_JEQ|BPF_K|BPF_JMPpermitted? The document currently has no restriction against it, but if it's permitted, the meaning is not explained.
Yes, it is permetted. It represents a 64bit reg compared to an imm.
Quoted 4 lines
Dave
64-bit immediate instructions clarification
The spec defines:
Quoted 5 lines
As discussed below in
64-bit immediate instructions_, a 64-bit immediate instruction uses a 64-bit immediate value that is constructed as follows. The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,dst_reg,src_reg, and offset all set to zero, and imm containing the high 32 bits of the immediate value.
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | imm
The 64-bit immediate instructions section then says:
Quoted 3 lines
Instructions with the ``BPF_IMM`` 'mode' modifier use the wide instruction encoding defined in
Instruction encoding_, and use the 'src' field of the basic instruction to hold an opcode subtype.
Some instructions then nicely state how to use the full 64 bit immediate value, such as
Quoted 3 lines
BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = imm64 integer integer BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst = map_val(map_by_fd(imm)) + next_imm map fd data pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x6 dst = map_val(map_by_idx(imm)) + next_imm map index data pointer
Others don't:
Quoted 4 lines
BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm) map fd map BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm) variable id data pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x4 dst = code_addr(imm) integer code pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x5 dst = map_by_idx(imm) map index map
How is next_imm used in those four? Must it be 0? Or can it be anything and it's ignored? Or is it used for something?
Dave
Yonghong Song
reviewerRe: 64-bit immediate instructions clarification
Quoted 16 lines · On 1/25/24 5:12 PM, [email protected] wrote:
The spec defines:
Quoted 5 lines
As discussed below in
64-bit immediate instructions_, a 64-bit immediate instruction uses a 64-bit immediate value that is constructed as follows. The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,dst_reg,src_reg, and offset all set to zero, and imm containing the high 32 bits of the immediate value.[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immThe 64-bit immediate instructions section then says:
Quoted 3 lines
Instructions with the ``BPF_IMM`` 'mode' modifier use the wide instruction encoding defined in
Instruction encoding_, and use the 'src' field of the basic instruction to hold an opcode subtype.Some instructions then nicely state how to use the full 64 bit immediate value, such as
Quoted 3 lines
BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = imm64 integer integer BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst = map_val(map_by_fd(imm)) + next_imm map fd data pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x6 dst = map_val(map_by_idx(imm)) + next_imm map index data pointer
Quoted 7 lines
Others don't:
Quoted 4 lines
BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm) map fd map BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm) variable id data pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x4 dst = code_addr(imm) integer code pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x5 dst = map_by_idx(imm) map index mapHow is
next_immused in those four? Must it be 0? Or can it be anything and it's ignored? Or is it used for something?
The other four must have next_imm to be 0. No use of next_imm in thee four insns kindly implies this. See uapi bpf.h for details (search BPF_PSEUDO_MAP_FD).
Quoted 3 lines
Dave
RE: 64-bit immediate instructions clarification
Quoted 31 lines · Yonghong Song
Quoted 3 lines · On 1/25/24 5:12 PM, [email protected] wrote:
The spec defines:
Quoted 2 lines
As discussed below in
64-bit immediate instructions_, a 64-bit immediate instruction uses a 64-bit immediate value that is constructed asfollows.
Quoted 3 lines
Quoted 3 lines
The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,
dst_reg,src_reg, and offset all set to zero, and imm containing the high 32 bits of theimmediate value.
Quoted 9 lines
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immThe 64-bit immediate instructions section then says:
Quoted 3 lines
Instructions with the ``BPF_IMM`` 'mode' modifier use the wide instruction encoding defined in
Instruction encoding_, and use the 'src' field of the basic instruction to hold an opcode subtype.Some instructions then nicely state how to use the full 64 bit immediate value, such as
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x0dst = imm64integer integer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x2dst = map_val(map_by_fd(imm))+
next_immmap fd data pointerQuoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x6dst = map_val(map_by_idx(imm))+
next_immmap index data pointerQuoted 2 lines
Others don't:
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x1dst =map_by_fd(imm)map fd map
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x3dst =var_addr(imm)variable id data pointer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x4dst =code_addr(imm)integer code pointer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x5dst =map_by_idx(imm)
Quoted 8 lines
map index map
Quoted 1 line
How is
next_immused in those four? Must it be 0? Or can it be anything andit's ignored?
Quoted 1 line
Or is it used for something?
The other four must have
next_immto be 0. No use ofnext_immin thee four insns kindly implies this.
See uapibpf.hfor details (searchBPF_PSEUDO_MAP_FD).
Thanks for confirming. The "Instruction encoding" section has misleading text in my opinion.
It nicely says:
Quoted 1 line
Note that most instructions do not use all of the fields. Unused fields shall be cleared to zero.
But then goes on to say:
Quoted 2 lines
As discussed below in 64-bit immediate instructions (Section 4.4), a 64-bit immediate instruction uses a 64-bit immediate value that is constructed as follows.
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | imm
Under a normal English reading, that could imply that all 64-bit immediate instructions use imm64, which is not the case. The whole imm64 discussion there only applies today to src=0 (though I
suppose it could be used by future 64-bit immediate instructions). Minimally I think
"a 64-bit immediate instruction uses" should be "some 64-bit immediate instructions use" but at present there's only one.
It would actually be simpler to remove the imm64 text and just have the definition of src 0x0 change from: "dst = imm64" to "dst = (next_imm << 32) | imm".
What do you think?
Dave
Yonghong Song
reviewerRe: 64-bit immediate instructions clarification
Quoted 55 lines · On 1/26/24 2:27 PM, [email protected] wrote:
Quoted 30 lines · Yonghong Song
Quoted 3 lines · On 1/25/24 5:12 PM, [email protected] wrote:
The spec defines:
Quoted 2 lines
As discussed below in
64-bit immediate instructions_, a 64-bit immediate instruction uses a 64-bit immediate value that is constructed asfollows.
Quoted 3 lines
Quoted 3 lines
The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,
dst_reg,src_reg, and offset all set to zero, and imm containing the high 32 bits of theimmediate value.
Quoted 9 lines
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immThe 64-bit immediate instructions section then says:
Quoted 3 lines
Instructions with the ``BPF_IMM`` 'mode' modifier use the wide instruction encoding defined in
Instruction encoding_, and use the 'src' field of the basic instruction to hold an opcode subtype.Some instructions then nicely state how to use the full 64 bit immediate value, such as
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x0dst = imm64integer integer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x2dst = map_val(map_by_fd(imm))+
next_immmap fd data pointerQuoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x6dst = map_val(map_by_idx(imm))+
next_immmap index data pointerQuoted 2 lines
Others don't:
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x1dst =map_by_fd(imm)map fd map
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x3dst =var_addr(imm)variable id data pointer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x4dst =code_addr(imm)integer code pointer
Quoted 8 lines
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x5dst =map_by_idx(imm)map index map
Quoted 1 line
How is
next_immused in those four? Must it be 0? Or can it be anything andit's ignored?
Quoted 1 line
Or is it used for something?
The other four must have
next_immto be 0. No use ofnext_immin thee four insns kindly implies this.
See uapibpf.hfor details (searchBPF_PSEUDO_MAP_FD).Thanks for confirming. The "Instruction encoding" section has misleading text in my opinion.
It nicely says:
Quoted 1 line
Note that most instructions do not use all of the fields. Unused fields shall be cleared to zero.
But then goes on to say:
Quoted 2 lines
As discussed below in 64-bit immediate instructions (Section 4.4), a 64-bit immediate instruction uses a 64-bit immediate value that is constructed as follows.
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immUnder a normal English reading, that could imply that all 64-bit immediate instructions use imm64, which is not the case. The whole imm64 discussion there only applies today to src=0 (though I
suppose it could be used by future 64-bit immediate instructions). Minimally I think
"a 64-bit immediate instruction uses" should be "some 64-bit immediate instructions use" but at present there's only one.
Quoted 4 lines
It would actually be simpler to remove the imm64 text and just have the definition of src
0x0change from: "dst = imm64" to "dst = (next_imm<< 32) | imm".What do you think?
it does sound better. Something like below?
Documentation/bpf/standardization/instruction-set.rst +4 -9
@@ -166,7 +166,7 @@ Note that most instructions do not use all of the fields. Unused fields shall be cleared to zero. As discussed below in `64-bit immediate instructions`_, a 64-bit immediate -instruction uses a 64-bit immediate value that is constructed as follows. +instruction uses two 32-bit immediate values that are constructed as follows. The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode, dst_reg, src_reg, and offset all set to zero, and imm containing the high 32 bits of the immediate value.
@@ -181,13 +181,8 @@ This is depicted in the following figure:: '--------------' pseudo instruction -Thus the 64-bit immediate value is constructed as follows: - - imm64 = (next_imm << 32) | imm - -where 'next_imm' refers to the imm value of the pseudo instruction -following the basic instruction. The unused bytes in the pseudo -instruction are reserved and shall be cleared to zero. +Here, the imm value of the pseudo instruction is called 'next_imm'. The unused +bytes in the pseudo instruction are reserved and shall be cleared to zero. Instruction classes -------------------
@@ -590,7 +585,7 @@ defined further below: ========================= ====== === ========================================= =========== ============== opcode construction opcode src pseudocode imm type dst type ========================= ====== === ========================================= =========== ============== -BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = imm64 integer integer +BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = (next_imm << 32) | imm integer integer BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm) map fd map BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst = map_val(map_by_fd(imm)) + next_imm map fd data pointer BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm) variable id data pointer
Quoted 3 lines
Dave
[email protected]
Acked-by Dave ThalerRE: 64-bit immediate instructions clarification
Quoted 125 lines
-----Original Message-----
From: Yonghong Song <[email protected]>
Sent: Friday, January 26, 2024 7:41 PM
To: [email protected]
Cc: [email protected]; [email protected]
Subject: Re: 64-bit immediate instructions clarificationQuoted 15 lines · On 1/26/24 2:27 PM, [email protected] wrote:
Quoted 14 lines · Yonghong Song
Quoted 4 lines · On 1/25/24 5:12 PM, [email protected] wrote:
The spec defines:
Quoted 3 lines
As discussed below in
64-bit immediate instructions_, a 64-bit immediate instruction uses a 64-bit immediate value that is constructed asfollows.
Quoted 4 lines
Quoted 4 lines
The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,
dst_reg,src_reg, and offset all set to zero, and imm containing the high 32 bits of theimmediate value.
Quoted 3 lines
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immThe 64-bit immediate instructions section then says:
Quoted 8 lines
Quoted 8 lines
Quoted 6 lines
Quoted 3 lines
Instructions with the ``BPF_IMM`` 'mode' modifier use the wide instruction encoding defined in
Instruction encoding_, and use the 'src' field of the basic instruction to hold an opcode subtype.Some instructions then nicely state how to use the full 64 bit immediate value, such as
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x0dst = imm64integer integer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x2dst =map_val(map_by_fd(imm))
Quoted 2 lines
Quoted 2 lines
+
next_immmap fd data pointerQuoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x6dst =map_val(map_by_idx(imm))
Quoted 13 lines
Quoted 13 lines
+
next_immmap index data pointerQuoted 2 lines
Others don't:
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x1dst =map_by_fd(imm)map fd map
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x3dst =var_addr(imm)variable id data pointer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x4dst =code_addr(imm)integer code pointer
Quoted 1 line
Quoted 1 line
BPF_IMM|BPF_DW|BPF_LD0x180x5dst =map_by_idx(imm)map index map
Quoted 2 lines
How is
next_immused in those four? Must it be 0? Or can it be anything andit's ignored?
Quoted 9 lines
Quoted 4 lines
Quoted 1 line
Or is it used for something?
The other four must have
next_immto be 0. No use ofnext_immin thee four insns kindly implies this.
See uapibpf.hfor details (searchBPF_PSEUDO_MAP_FD).Thanks for confirming. The "Instruction encoding" section has misleading text in my opinion.
It nicely says:
Quoted 1 line
Note that most instructions do not use all of the fields. Unused fields shall
be cleared to zero.
Quoted 3 lines
But then goes on to say:
Quoted 2 lines
As discussed below in 64-bit immediate instructions (Section 4.4), a 64-bit immediate instruction uses a 64-bit immediate value that is
constructed as follows.
Quoted 4 lines
[...]
Quoted 1 line
imm64 = (
next_imm<< 32) | immUnder a normal English reading, that could imply that all 64-bit immediate instructions use imm64, which is not the case. The whole imm64
discussion there only applies today to src=0 (though I
Quoted 1 line
suppose it could be used by future 64-bit immediate instructions). Minimally
I think
Quoted 1 line
"a 64-bit immediate instruction uses" should be "some 64-bit immediate
instructions use"
Quoted 4 lines
but at present there's only one.
It would actually be simpler to remove the imm64 text and just have the definition of src
0x0change from: "dst = imm64" to "dst = (next_imm<<32) | imm".
Quoted 2 lines
What do you think?
it does sound better. Something like below?
Documentation/bpf/standardization/instruction-set.rst +0
-0@@ -166,7 +166,7 @@ Note that most instructions do not use all of the fields. Unused fields shall be cleared to zero. As discussed below in `64-bit immediate instructions`_, a 64-bit immediate -instruction uses a 64-bit immediate value that is constructed as follows. +instruction uses two 32-bit immediate values that are constructed as follows.
The 64 bits following the basic instruction contain a pseudo instruction using the same format but with opcode,dst_reg,src_reg, and offset all set to
zero,
and imm containing the high 32 bits of the immediate value.Documentation/bpf/standardization/instruction-set.rst +0
-5@@ -181,13 +181,8 @@ This is depicted in the following figure:: '--------------' pseudo instruction -Thus the 64-bit immediate value is constructed as follows: - - imm64 = (next_imm << 32) | imm - -where 'next_imm' refers to the imm value of the pseudo instruction -followingthe basic instruction. The unused bytes in the pseudo -instruction are reserved and shall be cleared to zero.
Documentation/bpf/standardization/instruction-set.rst +2
-0+Here, the imm value of the pseudo instruction is called 'next_imm'. The +unused bytes in the pseudo instruction are reserved and shall be cleared tozero.
Instruction classes
-------------------Documentation/bpf/standardization/instruction-set.rst +0
-0@@ -590,7 +585,7 @@ defined further below: ========================= ====== ============================================ ===========
==============
opcode construction opcode src pseudocode imm type
dst type
========================= ====== ===
========================================= ===========
==============
-BPF_IMM |BPF_DW|BPF_LD0x180x0dst = imm64
integer integer
Quoted 8 lines
+BPF_IMM |
BPF_DW|BPF_LD0x180x0dst = (next_imm<< 32) | imm
integer integer
BPF_IMM|BPF_DW|BPF_LD0x180x1dst =map_by_fd(imm)
map fd map
BPF_IMM|BPF_DW|BPF_LD0x180x2dst = map_val(map_by_fd(imm)) +next_immmap fd data pointer
BPF_IMM|BPF_DW|BPF_LD0x180x3dst =var_addr(imm)
variable id data pointer