Skip to contentSkip to conversation

Register encoding in assembly for load/store instructions

DISCUSSION Jose E. Marchesi 4 participants 16 messages Jul 25, 2023 – Jul 28, 2023 BPF

lore
Share & tools
lore
#0 lore raw

Hello Yonghong.

We have noticed that the llvm disassembler uses different notations for registers in load and store instructions, depending somehow on the width of the data being loaded or stored.

For example, this is an excerpt from the assembler-disassembler.s test file in llvm:

// Note: For the group below w1 is used as a destination for sizes u8, u16, u32.
// This is disassembler quirk, but is technically not wrong, as there are
// no different encodings for 'r1 = load' vs 'w1 = load'.
//
// CHECK: 71 21 2a 00 00 00 00 00 w1 = *(u8 *)(r2 + 0x2a)
// CHECK: 69 21 2a 00 00 00 00 00 w1 = *(u16 *)(r2 + 0x2a)
// CHECK: 61 21 2a 00 00 00 00 00 w1 = *(u32 *)(r2 + 0x2a)
// CHECK: 79 21 2a 00 00 00 00 00 r1 = *(u64 *)(r2 + 0x2a)
r1 = *(u8*)(r2 + 42)
r1 = *(u16*)(r2 + 42)
r1 = *(u32*)(r2 + 42)
r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the u8, u16 and u32 cases is a "disassembler quirk".

Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.

Is that intended?

reviewer
#1 lore raw
Quoted 23 lines · Jose E. Marchesi

Hello Yonghong.

We have noticed that the llvm disassembler uses different notations for registers in load and store instructions, depending somehow on the width of the data being loaded or stored.

For example, this is an excerpt from the assembler-disassembler.s test file in llvm:

   // Note: For the group below w1 is used as a destination for sizes u8, u16, u32.
   //       This is disassembler quirk, but is technically not wrong, as there are
   //       no different encodings for 'r1 = load' vs 'w1 = load'.
   //
   // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
   // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
   // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
   // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
   r1 = *(u8*)(r2 + 42)
   r1 = *(u16*)(r2 + 42)
   r1 = *(u32*)(r2 + 42)
   r1 = *(u64*)(r2 + 42)
Quoted 7 lines

The comment there clarifies that the usage of wN instead of rN in the u8, u16 and u32 cases is a "disassembler quirk".

Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.

Is that intended?

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Quoted 1 line
#2 lore raw
Quoted 30 lines · Jose E. Marchesi
Quoted 19 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

   // Note: For the group below w1 is used as a destination for

sizes u8, u16, u32.
// This is disassembler quirk, but is technically not wrong, as there are
// no different encodings for 'r1 = load' vs 'w1 = load'.
//
// CHECK: 71 21 2a 00 00 00 00 00 w1 = *(u8 *)(r2 + 0x2a)
// CHECK: 69 21 2a 00 00 00 00 00 w1 = *(u16 *)(r2 + 0x2a)
// CHECK: 61 21 2a 00 00 00 00 00 w1 = *(u32 *)(r2 + 0x2a)
// CHECK: 79 21 2a 00 00 00 00 00 r1 = *(u64 *)(r2 + 0x2a)
r1 = *(u8*)(r2 + 42)
r1 = *(u16*)(r2 + 42)

Quoted 8 lines

r1 = *(u32*)(r2 + 42)
r1 = *(u64*)(r2 + 42)
The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 3 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
#3 lore raw
Quoted 31 lines
Quoted 31 lines · Jose E. Marchesi
Quoted 28 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

   // Note: For the group below w1 is used as a destination for

sizes u8, u16, u32.
// This is disassembler quirk, but is technically not wrong, as
there are
// no different encodings for 'r1 = load' vs 'w1 = load'.
//
// CHECK: 71 21 2a 00 00 00 00 00 w1 = *(u8 *)(r2 + 0x2a)
// CHECK: 69 21 2a 00 00 00 00 00 w1 = *(u16 *)(r2 + 0x2a)
// CHECK: 61 21 2a 00 00 00 00 00 w1 = *(u32 *)(r2 + 0x2a)
// CHECK: 79 21 2a 00 00 00 00 00 r1 = *(u64 *)(r2 + 0x2a)
r1 = *(u8*)(r2 + 42)
r1 = *(u16*)(r2 + 42)
r1 = *(u32*)(r2 + 42)
r1 = *(u64*)(r2 + 42)
The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Sorry my keyboard num-lock activated mid-sentence.

I meant 'r1 = (u8*)(r2 + 42)'.
Why supporting that syntax as well as 'w1 = (u8*)(r2 + 42)'?

Quoted 11 lines
Quoted 4 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
reviewer
#4 lore raw
Quoted 34 lines · Jose E. Marchesi
Quoted 34 lines
Quoted 33 lines · Jose E. Marchesi
Quoted 22 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

    // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
    // This is disassembler quirk, but is technically not wrong, as
there are
    //       no different encodings for 'r1 = load' vs 'w1 = load'.
    //
    // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
    // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
    // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
    // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
    r1 = *(u8*)(r2 + 42)
    r1 = *(u16*)(r2 + 42)
    r1 = *(u32*)(r2 + 42)
    r1 = *(u64*)(r2 + 42)
Quoted 6 lines

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

Quoted 7 lines
Quoted 2 lines

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Sorry my keyboard num-lock activated mid-sentence.

I meant 'r1 = (u8*)(r2 + 42)'.
Why supporting that syntax as well as 'w1 = (u8*)(r2 + 42)'?

alu32 mode. Original intention is that if
w1 = *(u8 *)(r2 + 42)
is specified that the hardware will actually only load the value to the 32-bit sub-register. And then hardware will be doing 32-to-64 zero extension automatically.

This is different from
r1 = *(u8 *)(r2 + 42)
where the value will actually load into the 64-bit register by insn itself.

Quoted 12 lines
Quoted 12 lines
Quoted 5 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
reviewer
#5 lore raw
In reply to Jose E. Marchesi
Quoted 30 lines · Jose E. Marchesi
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

    // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
    //       This is disassembler quirk, but is technically not wrong, as there are
    //       no different encodings for 'r1 = load' vs 'w1 = load'.
    //
    // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
    // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
    // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
    // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
    r1 = *(u8*)(r2 + 42)
    r1 = *(u16*)(r2 + 42)
    r1 = *(u32*)(r2 + 42)
    r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 11 lines
Quoted 4 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
#6 lore raw
Quoted 39 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

    // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
    //       This is disassembler quirk, but is technically not wrong, as there are
    //       no different encodings for 'r1 = load' vs 'w1 = load'.
    //
    // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
    // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
    // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
    // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
    r1 = *(u8*)(r2 + 42)
    r1 = *(u16*)(r2 + 42)
    r1 = *(u32*)(r2 + 42)
    r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?

But what concern us is the assembler, not the disassembler.

clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.

So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 10 lines
Quoted 10 lines
Quoted 4 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
reviewer
#7 lore raw
Quoted 52 lines · Jose E. Marchesi
Quoted 39 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

     // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
     //       This is disassembler quirk, but is technically not wrong, as there are
     //       no different encodings for 'r1 = load' vs 'w1 = load'.
     //
     // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
     // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
     // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
     // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
     r1 = *(u8*)(r2 + 42)
     r1 = *(u16*)(r2 + 42)
     r1 = *(u32*)(r2 + 42)
     r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?

Quoted 8 lines

But what concern us is the assembler, not the disassembler.

clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.

So, should we support both syntaxes as _input_ syntax in the assembler?

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So
w1 = *(u8 *)(r2 + 42)
is preferred.

Quoted 11 lines
Quoted 11 lines
Quoted 11 lines
Quoted 5 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
#8 lore raw
Quoted 59 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

     // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
     //       This is disassembler quirk, but is technically not wrong, as there are
     //       no different encodings for 'r1 = load' vs 'w1 = load'.
     //
     // CHECK: 71 21 2a 00 00 00 00 00	w1 = *(u8 *)(r2 + 0x2a)
     // CHECK: 69 21 2a 00 00 00 00 00	w1 = *(u16 *)(r2 + 0x2a)
     // CHECK: 61 21 2a 00 00 00 00 00	w1 = *(u32 *)(r2 + 0x2a)
     // CHECK: 79 21 2a 00 00 00 00 00	r1 = *(u64 *)(r2 + 0x2a)
     r1 = *(u8*)(r2 + 42)
     r1 = *(u16*)(r2 + 42)
     r1 = *(u32*)(r2 + 42)
     r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So
w1 = *(u8 *)(r2 + 42)
is preferred.

We have V4 by default now. So we can emit

w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

r1 = *(u8 *)(r2 + 42)

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 12 lines
Quoted 6 lines

Note that for newer sign-extended loads, even at alu32 mode, only r* register is used since the sign-extension extends upto 64 bits for all variants (8/16/32).

Yes we noticed that :)

Quoted 4 lines
Quoted 4 lines
#9 lore raw
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

     // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
     //       This is disassembler quirk, but is technically not wrong, as there are
     //       no different encodings for 'r1 = load' vs 'w1 = load'.
     //
     // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
     // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
     // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
     // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
     r1 = *(u8*)(r2 + 42)
     r1 = *(u16*)(r2 + 42)
     r1 = *(u32*)(r2 + 42)
     r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So
w1 = *(u8 *)(r2 + 42)
is preferred.

We have V4 by default now. So we can emit

w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

r1 = *(u8 *)(r2 + 42)

Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

maintainer
#10 lore raw
Quoted 99 lines · Alexei Starovoitov
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

     // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
     //       This is disassembler quirk, but is technically not wrong, as there are
     //       no different encodings for 'r1 = load' vs 'w1 = load'.
     //
     // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
     // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
     // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
     // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
     r1 = *(u8*)(r2 + 42)
     r1 = *(u16*)(r2 + 42)
     r1 = *(u32*)(r2 + 42)
     r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So
w1 = *(u8 *)(r2 + 42)
is preferred.

We have V4 by default now. So we can emit

w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

r1 = *(u8 *)(r2 + 42)

Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

Quoted 5 lines

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

I agree with Alexei (the ... disassembler quirk ... comment is left by me :). Can dig into clang part of things if this is a consensus.

reviewer
#11 lore raw
Quoted 100 lines · Eduard Zingerman
Quoted 99 lines · Alexei Starovoitov
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

      // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
      //       This is disassembler quirk, but is technically not wrong, as there are
      //       no different encodings for 'r1 = load' vs 'w1 = load'.
      //
      // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
      // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
      // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
      // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
      r1 = *(u8*)(r2 + 42)
      r1 = *(u16*)(r2 + 42)
      r1 = *(u32*)(r2 + 42)
      r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So

    w1 = *(u8 *)(r2 + 42)

is preferred.

We have V4 by default now. So we can emit

   w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

   r1 = *(u8 *)(r2 + 42)
Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

Quoted 8 lines
Quoted 5 lines

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

I agree with Alexei (the ... disassembler quirk ... comment is left by me :). Can dig into clang part of things if this is a consensus.

For disassembler, we have stx as well may use w* registers with alu32. In llvm BPFDisassembler.cpp, we have

if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&

      getInstSize(Insn) != BPF_DW &&
      (InstMode == BPF_MEM || InstMode == BPF_ATOMIC) &&
      STI.hasFeature(BPF::ALU32))
    Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn, 
Address,
                               this, STI);
  else
    Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address, 
this,
                               STI);

Maybe we should just do

Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this, STI);

So we already disassemble based on non-alu32 mode?

maintainer
#12 lore raw
Quoted 126 lines · Yonghong Song
Quoted 100 lines · Eduard Zingerman
Quoted 99 lines · Alexei Starovoitov
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

      // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
      //       This is disassembler quirk, but is technically not wrong, as there are
      //       no different encodings for 'r1 = load' vs 'w1 = load'.
      //
      // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
      // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
      // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
      // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
      r1 = *(u8*)(r2 + 42)
      r1 = *(u16*)(r2 + 42)
      r1 = *(u32*)(r2 + 42)
      r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So

    w1 = *(u8 *)(r2 + 42)

is preferred.

We have V4 by default now. So we can emit

   w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

   r1 = *(u8 *)(r2 + 42)
Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

Quoted 8 lines
Quoted 5 lines

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

I agree with Alexei (the ... disassembler quirk ... comment is left by me :). Can dig into clang part of things if this is a consensus.

For disassembler, we have stx as well may use w* registers with alu32. In llvm BPFDisassembler.cpp, we have

   if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
       getInstSize(Insn) != BPF_DW &&
       (InstMode == BPF_MEM || InstMode == BPF_ATOMIC) &&
       STI.hasFeature(BPF::ALU32))
     Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn, 
Address,
                                this, STI);
   else
     Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address, 
this,
                                STI);
Quoted 7 lines

Maybe we should just do

Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this, STI);

So we already disassemble based on non-alu32 mode?

Yes, this changes llvm-objdump behavior to emit 64-bit registers on LHS.

maintainer
#13 lore raw
In reply to Yonghong Song
Quoted 126 lines · Yonghong Song
Quoted 100 lines · Eduard Zingerman
Quoted 99 lines · Alexei Starovoitov
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

      // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
      //       This is disassembler quirk, but is technically not wrong, as there are
      //       no different encodings for 'r1 = load' vs 'w1 = load'.
      //
      // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
      // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
      // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
      // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
      r1 = *(u8*)(r2 + 42)
      r1 = *(u16*)(r2 + 42)
      r1 = *(u32*)(r2 + 42)
      r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So

    w1 = *(u8 *)(r2 + 42)

is preferred.

We have V4 by default now. So we can emit

   w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

   r1 = *(u8 *)(r2 + 42)
Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

Quoted 8 lines
Quoted 5 lines

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

I agree with Alexei (the ... disassembler quirk ... comment is left by me :). Can dig into clang part of things if this is a consensus.

For disassembler, we have stx as well may use w* registers with alu32. In llvm BPFDisassembler.cpp, we have

   if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
       getInstSize(Insn) != BPF_DW &&
       (InstMode == BPF_MEM || InstMode == BPF_ATOMIC) &&
       STI.hasFeature(BPF::ALU32))
     Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn, 
Address,
                                this, STI);
   else
     Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address, 
this,
                                STI);
Quoted 7 lines

Maybe we should just do

Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this, STI);

So we already disassemble based on non-alu32 mode?

Yonghong, Alexei,

I have a prototype [1] that consolidates STW/STW32, LDW/LDW32 etc instructions in LLVM BPF backend, thus removing the syntactic difference. I think it simplifies BPFInstrInfo.td a bit but that's up to debate.

Should I proceed with it?

[1] https://reviews.llvm.org/D156559

#14 lore raw
Quoted 26 lines · Eduard Zingerman
Quoted 16 lines

For disassembler, we have stx as well may use w* registers with alu32. In llvm BPFDisassembler.cpp, we have

   if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
       getInstSize(Insn) != BPF_DW &&
       (InstMode == BPF_MEM || InstMode == BPF_ATOMIC) &&
       STI.hasFeature(BPF::ALU32))
     Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn,
Address,
                                this, STI);
   else
     Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this,
                                STI);
Quoted 7 lines

Maybe we should just do

Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this, STI);

So we already disassemble based on non-alu32 mode?

Yonghong, Alexei,

Quoted 8 lines

I have a prototype [1] that consolidates STW/STW32, LDW/LDW32 etc instructions in LLVM BPF backend, thus removing the syntactic difference. I think it simplifies BPFInstrInfo.td a bit but that's up to debate.

Should I proceed with it?

[1] https://reviews.llvm.org/D156559

Makes sense to me.

reviewer
#15 lore raw
In reply to Eduard Zingerman
Quoted 137 lines · Eduard Zingerman
Quoted 124 lines · Yonghong Song
Quoted 100 lines · Eduard Zingerman
Quoted 99 lines · Alexei Starovoitov
Quoted 75 lines · Jose E. Marchesi
Quoted 60 lines · Jose E. Marchesi
Quoted 44 lines
Quoted 38 lines · Jose E. Marchesi
Quoted 30 lines
Quoted 30 lines · Jose E. Marchesi
Quoted 27 lines

Hello Yonghong.
We have noticed that the llvm disassembler uses different notations for
registers in load and store instructions, depending somehow on the width of the data being loaded or stored.
For example, this is an excerpt from the assembler-disassembler.s test
file in llvm:

       // Note: For the group below w1 is used as a destination for
sizes u8, u16, u32.
       //       This is disassembler quirk, but is technically not wrong, as there are
       //       no different encodings for 'r1 = load' vs 'w1 = load'.
       //
       // CHECK: 71 21 2a 00 00 00 00 00   w1 = *(u8 *)(r2 + 0x2a)
       // CHECK: 69 21 2a 00 00 00 00 00   w1 = *(u16 *)(r2 + 0x2a)
       // CHECK: 61 21 2a 00 00 00 00 00   w1 = *(u32 *)(r2 + 0x2a)
       // CHECK: 79 21 2a 00 00 00 00 00   r1 = *(u64 *)(r2 + 0x2a)
       r1 = *(u8*)(r2 + 42)
       r1 = *(u16*)(r2 + 42)
       r1 = *(u32*)(r2 + 42)
       r1 = *(u64*)(r2 + 42)

The comment there clarifies that the usage of wN instead of rN in the
u8, u16 and u32 cases is a "disassembler quirk".
Anyway, the problem is that it seems that `clang -S' actually emits these forms with wN.
Is that intended?

Quoted 5 lines
Quoted 2 lines

Yes, this is intended since alu32 mode is enabled where w* registers are used for 8/16/32 bit load.

So then why suppporting 'r1 = 8948 8*9r2 + 0x2a)'? The mode is still
alu32 mode. Isn't the u{8,16,32} part enough to discriminate?

Quoted 6 lines

What does this 'r1 = 8948 8*9r2 + 0x2a)' mean?

For u8/u16/u32 loads, if objdump with option to indicate alu32 mode, then w* register is used. If no alu32 mode for objdump, then r* register is used. Basically the same insn, disasm is different depending on alu32 mode or not. u8/u16/u32 is not enough to differentiate.

Quoted 12 lines

Ok, so the llvm objdump has a switch that tells when to use rN or wN when printing these particular instructions. Thats the "disassembler quirk". To what purpose? Isnt the person passing the command line switch the same person reading the disassembled program? Is this "alu32 mode" more than a cosmetic thing?
But what concern us is the assembler, not the disassembler. clang -S (which is not objdump) seems to generate these instructions with wN (see https://godbolt.org/z/5G433Yvrb for a store instruction for example) and we assume the output of clang -S is intended to be passed to an assembler, much like with gcc -S.
So, should we support both syntaxes as _input_ syntax in the assembler?

Quoted 6 lines

Considering -mcpu=v3 is recommended cpu flavor (at least in bpf mailing list), and -mcpu=v3 has alu32 enabled by default. So I think gcc can start to emit insn assuming alu32 mode is on by default. So

     w1 = *(u8 *)(r2 + 42)

is preferred.

We have V4 by default now. So we can emit

    w1 = *(u8 *)(r2 + 42)

when -mcpu is v3 or higher, or if -malu32 is specified, and

    r1 = *(u8 *)(r2 + 42)
Quoted 8 lines

when -mcpu is v2 or lower, or if -mnoalu32 is specified.

Sounds good?

However this implies that the assembler should indeed recognize both forms of instructions. But note that it will assembly them to the exactly same encoded instruction. This includes inline asm (remember GCC does not have an integrated assembler.)

Good point.
I think we made a mistake in clang.
We shouldn't be printing
w1 = *(u8 *)(r2 + 42)
since such instruction doesn't exist in BPF ISA and it's confusing.
There is only one instruction:
r1 = *(u8 *)(r2 + 42)
which is an 8-bit load that zero extends into 64-bit. x86 JIT actually implements it as 8-bit load that stores into a 32-bit subregister, so it kinda matches w1, but that's an implementation detail of the JIT.

Quoted 8 lines
Quoted 5 lines

I think both gcc and clang should always print r1 = *(u8 *)(r2 + 42) regardless of alu32 or not.
In gas and clang assembler we can support both w1= and r1= flavors for backward compat.

I agree with Alexei (the ... disassembler quirk ... comment is left by me :). Can dig into clang part of things if this is a consensus.

For disassembler, we have stx as well may use w* registers with alu32. In llvm BPFDisassembler.cpp, we have

    if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
        getInstSize(Insn) != BPF_DW &&
        (InstMode == BPF_MEM || InstMode == BPF_ATOMIC) &&
        STI.hasFeature(BPF::ALU32))
      Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn,

Address,
this, STI);
else
Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this,

Quoted 9 lines
                                 STI);

Maybe we should just do

Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address,
this, STI);

So we already disassemble based on non-alu32 mode?

Yonghong, Alexei,

Quoted 8 lines

I have a prototype [1] that consolidates STW/STW32, LDW/LDW32 etc instructions in LLVM BPF backend, thus removing the syntactic difference. I think it simplifies BPFInstrInfo.td a bit but that's up to debate.

Should I proceed with it?

[1] https://reviews.llvm.org/D156559

I made a comment to the diff w.r.t. backward compatibility issue.