macro-expander: Problem when comparing 32 bit constant with W register

[AndreasKrall]

The following 32 bit code for instruction SVEWHILEBWGE from sys/arch/sve behaves wrong (expanded macros):

  register        S : Index -> BitsX  // general purpose register file with stack pointer
  [overwrite source: zero]            // S is overwritten on write by zero extending the written value
  alias register  R = S(*)(31..0)     // lower half of general purpose register file with stack pointer
  [zero : X(31)]                      // X(31) is the zero register
  alias register  X = S               // general purpose register file with zero register
  [zero : W(31)]                      // X(31) is the zero register
  [overwrite source: zero]            // X is overwritten on write by zero extending the written value
  alias register W  = X(*)(31..0)     // lower half of general purpose register file with zero register


  constant MinSIntW : SIntW = 0x8000'0000

  instruction SVEWHILEBWGE : SVEWhileFormat =
    let left  = W(rn) in
    let right = W(rm) in
      let pred =
        if right = MinSIntW then
          PTrueB
        else
          ...
        }

The path for right = MinSIntW is not taken, whereas the code for the 64 bit variant works fine:

  constant MinSIntX : SIntX = 0x8000'0000'0000'0000

  instruction SVEWHILEBXGE : SVEWhileFormat =
    let left  = X(rn) in
    let right = X(rm) in
      let pred =
        if right = MinSIntX then
          PTrueB
        else
          ...

I assume that there are some typing and sign extension issues. Interestingly in the typed AST left and right are 64 bit, but right is later casted to SIntW in the comparison. But in the behavior graph it looks fine again.

The problem has been shown up in the following test code:

    mov     x3,  #0
    addvl   x3,  x3,  #1
    mov     w8,  #1
    ror     w8,  w8,  #1
    add     w9,  w8,  #1
    whilege p0.b,w8,  w8
    whilege p1.b,w9,  w8
    whilehs p2.b,w8,  w8
    whilehs p3.b,w9,  w8
    cntp    x13, p0, p0.b
    cntp    x14, p1, p1.b
    cntp    x15, p2, p2.b
    cntp    x16, p3, p3.b
    cmp     x13, x3
    b.ne    exit
    add     x2,  x2, #1
    cmp     x14, x3
    b.ne    exit
    add     x2,  x2, #1
    cmp     x15, x5
    b.ne    exit
    add     x2,  x2, #1
    cmp     x16, x6
    b.ne    exit
    add     x2,  x2, #1         // x2 = 0xA0

This test works fine:

    mov     x8,  #1
    ror     x8,  x8,  #1
    add     x9,  x8,  #1
    whilege p0.b,x8,  x8
    whilege p1.b,x9,  x8
    whilehs p2.b,x8,  x8
    whilehs p3.b,x9,  x8

And of course upstream QEMU produces the right result.

[AndreasKrall]

@flofriday, it seems that the problem is coming from the type checker. If I change constant MinSIntW : SIntW = 0x8000'0000 to constant MinSIntW : UIntW = 0x8000'0000 everything works fine. It seems that you have a wrong 64 bit sized type for the 32 bit W register, there is a zero extension for the extract of the W register and a sign extension for the 32 bit signed constant and then a 64 bit comparison is done instead of a 32 bit comparison. The ror instruction produces a correct result, but it has additional casts.
The typed AST is:

. InstructionDefinition name: "SVEWHILEBWGE"
. : Identifier name: "SVEWhileFormat" type: null
. : LetStatement
. : ' Identifier name: "left" type: Bits<64>
. : ' CallIndexExpr type: Bits<32>
. : ' | Identifier name: "W" type: null
. : ' | ArgsIndices
. : ' | . Identifier name: "rn" type: Bits<5>
. : ' LetStatement
. : ' | Identifier name: "right" type: Bits<64>
. : ' | CallIndexExpr type: Bits<32>
. : ' | . Identifier name: "W" type: null
. : ' | . ArgsIndices
. : ' | . : Identifier name: "rm" type: Bits<5>

[AndreasKrall]

When I change the code from:

  constant MinSIntW : SIntW = 0x8000'0000

  instruction SVEWHILEBWGE : SVEWhileFormat =
    let left  = W(rn) in
    let right = W(rm) in
      let pred =
        if right = MinSIntW then
          PTrueB
        else
          ...
        }

to (Size::WSize = 32)

  constant MinSIntW : SIntW = 0x8000'0000

  instruction SVEWHILEBWGE : SVEWhileFormat =
    let left  = W(rn) as Bits<Size::WSize> in
    let right = W(rm) as Bits<Size::WSize> in
      let pred =
        if right = MinSIntW then
          PTrueB
        else
          ...
        }

the typed AST still has left as 64 bit.

. InstructionDefinition name: "SVEWHILEBWGE"
. : Identifier name: "SVEWhileFormat" type: null
. : LetStatement
. : ' Identifier name: "left" type: Bits<64>
. : ' CastExpr type: Bits<32>
. : ' | CallIndexExpr type: Bits<32>
. : ' | . Identifier name: "W" type: null
. : ' | . ArgsIndices
. : ' | . : Identifier name: "rn" type: Bits<5>
. : ' | TypeLiteral type: Bits<32>
. : ' | . Identifier name: "Bits" type: null
. : ' | . IdentifierPath type: Const<32>
. : ' LetStatement
. : ' | Identifier name: "right" type: Bits<64>
. : ' | CastExpr type: Bits<32>
. : ' | . CallIndexExpr type: Bits<32>
. : ' | . : Identifier name: "W" type: null
. : ' | . : ArgsIndices
. : ' | . : ' Identifier name: "rm" type: Bits<5>
. : ' | . TypeLiteral type: Bits<32>
. : ' | . : Identifier name: "Bits" type: null
. : ' | . : IdentifierPath type: Const<32>

@flofriday, can you comment on this?

[flofriday]

As far as I can tell this doesn't make any sense and the declared identifier should have the size of the initialization expression.
I currently have a lot of uni assignments but I will try to look at it over the weekend

[AndreasKrall]

No worries, I have a workaround for that bug.