Skip to contentSkip to conversation

Sign extension ISA question

Bpf [email protected] 3 participants 12 messages Jan 16, 2024 – Jan 27, 2024

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

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
#1 lore raw

(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

reviewer
#2 lore raw
Quoted 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

#3 lore raw
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_MOVSX only 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

reviewer
#4 lore raw
Quoted 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_MOVSX only 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.

#5 lore raw

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

reviewer
#6 lore raw

Re: 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 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_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_JMP32 class 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_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.

Yes, it is permetted. It represents a 64bit reg compared to an imm.

Quoted 4 lines

Dave

#7 lore raw

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

reviewer
#8 lore raw

Re: 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) | 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
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    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?

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

#9 lore raw

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 as

follows.

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 the

immediate value.

Quoted 9 lines

[...]

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 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = imm64

integer integer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst = map_val(map_by_fd(imm))

+ next_imm map fd data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x6 dst = map_val(map_by_idx(imm))

+ next_imm map index data pointer

Quoted 2 lines

Others don't:

Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm)

map fd map

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm)

variable id data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x4 dst = code_addr(imm)

integer code pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x5 dst = map_by_idx(imm)

Quoted 8 lines

map index map

Quoted 1 line

How is next_imm used in those four? Must it be 0? Or can it be anything and

it's ignored?

Quoted 1 line

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).

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

reviewer
#10 lore raw

Re: 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 as

follows.

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 the

immediate value.

Quoted 9 lines

[...]

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 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x0 dst = imm64

integer integer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst = map_val(map_by_fd(imm))

+ next_imm map fd data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x6 dst = map_val(map_by_idx(imm))

+ next_imm map index data pointer

Quoted 2 lines

Others don't:

Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm)

map fd map

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm)

variable id data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x4 dst = code_addr(imm)

integer code pointer

Quoted 8 lines
Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x5 dst = map_by_idx(imm)

map index map

Quoted 1 line

How is next_imm used in those four? Must it be 0? Or can it be anything and

it's ignored?

Quoted 1 line

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).

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.

Quoted 4 lines

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?

it does sound better. Something like below?

Documentation/bpf/standardization/instruction-set.rst +4 -9
index af43227b6ee4..fceacca46299 100644
@@ -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

Acked-by Dave Thaler
#11 lore raw

RE: 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 clarification

Quoted 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 as

follows.

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 the

immediate value.

Quoted 3 lines

[...]

Quoted 1 line

imm64 = (next_imm << 32) | imm

The 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_LD 0x18 0x0 dst = imm64

integer integer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x2 dst =

map_val(map_by_fd(imm))

Quoted 2 lines
Quoted 2 lines

+ next_imm map fd data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x6 dst =

map_val(map_by_idx(imm))

Quoted 13 lines
Quoted 13 lines

+ next_imm map index data pointer

Quoted 2 lines

Others don't:

Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x1 dst = map_by_fd(imm)

map fd map

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x3 dst = var_addr(imm)

variable id data pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x4 dst = code_addr(imm)

integer code pointer

Quoted 1 line
Quoted 1 line

BPF_IMM | BPF_DW | BPF_LD 0x18 0x5 dst = map_by_idx(imm)

map index map

Quoted 2 lines

How is next_imm used in those four? Must it be 0? Or can it be anything and

it's ignored?

Quoted 9 lines
Quoted 4 lines
Quoted 1 line

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).

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) | 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

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 0x0 change 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
index af43227b6ee4..fceacca46299 100644
@@ -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 -following

the 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 to

zero.

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_LD 0x18 0x0 dst = imm64
integer integer

Quoted 8 lines

+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