parser: Support for transformations

[kper]

The VADL specification defines instruction in the binary representation. For the compiler and parser, we have to use decoding functions (e.g field access functions) to access the "true" value of a field. The inverse of that is the encoding function.
However, we are lacking functions for the assembly representation because sometimes it is possible that the assembly representation of an instruction is different than the value in the underlying MCInst.

For example lui t0, 1 # t0 = 1 << 12 = 0x1000 = 4096. Here the immediate operand in the assembly has 1 while the internal value is 4096.
Until the PR #361, we used the decoding functions for the binary representation (field access function) to handle these cases. If you defined in your assembly grammar the field name as an operand, then we automatically used the decoding function for this field to convert the value. But with the support of field access functions with multiple fields, this approach is quite hard because we don't the field values in the assembly. Additionally, it might be the case that the assembly representation is different the representation in the binary encoding. Those cases are not supported right now.

Therefore, I propose to remove the support for fields in the assembly parser grammar. It is only allowed to define the instruction's operands.
And I propose to extend the syntax with a new function to decode an assembly immediate operand.

format Utype : Inst =                   // Utype upper immediate instruction format
    { imm    : Bits<20>                   // [31..12] 20 bit immediate value
    , rd     : Index                      // [11..7]  destination register index
    , opcode : Bits7                      // [6..0]   7 bit operation code
    , immUp  = (imm as SIntR) << 12       // shifted signed immediate value
    }

  model UtypeInstr (name : Id, opcode : Bin, rhsEx : Ex) : IsaDefs = {
    instruction $name : Utype =                        // upper immediate instructions
      X(rd) := $rhsEx
    encoding $name = {opcode = $opcode}
    assembly $name = (mnemonic, " ", register(rd), ",", hex(imm))
    }

   function lui(x) return x << 12

   LuiInstruction @instruction:
      mnemonic = "LUI" @operand
      rd = Register@operand ","
      immUp = lui(LuiImmediateOperand)
    ;

   LuiImmediateOperand :
      ImmediateOperand
      | op = (
          "%" mod="hi"@modifier
          "(" val = Expression ")"
        ) @operand
    ;

[AndreasKrall]

We already support transformation functions in the assembly grammar. But different to your example we have to use angle brackets as the parentheses are used for grouping. Your example has to be written as:

   LuiInstruction @instruction:
      mnemonic = "LUI" @operand
      rd = Register@operand ","
      immUp = lui<LuiImmediateOperand>
    ;

And we had to add some hacks in the scanner to handle the angle brackets correctly (especially if nested).