add Zclsd extension instructions

Author: Shehrozkashif

arch/inst/Zclsd/c.ld.yaml

@@ -0,0 +1,44 @@
+# yaml-language-server: $schema=../../../schemas/inst_schema.json
+
+$schema: "inst_schema.json#"
+kind: instruction
+name: c.ld
+long_name: Load doubleword to even/odd register pair, 16-bit encoding
+description: |
+  Loads a 64-bit value into registers rd' and rd'+1. It computes an effective address by adding the
+  zero-extended offset, scaled by 8, to the base address in register rs1'.
+definedBy:
+  anyOf: [Zclsd]
+assembly: c.ld rd', offset(rs1')
+encoding:
+  match: 011-----------00
+  variables:
+    - name: rd
+      location: 4-2
+    - name: imm
+      location: 9-7
+    - name: rs1
+      location: 12-10|6-5
+access:
+  s: always
+  u: always
+  vs: always
+  vu: always
+operation(): |
+
+  Bits<XLEN> base = X[rs1];
+  Bits<XLEN> offset = imm << 3;
+  Bits<XLEN> eff_addr = base + offset;
+
+  Bits<64> data = read_memory<64>(eff_addr, $encoding);
+
+  if (rd != 0 && (rd & 0x1) == 0) {
+    X[rd]   = data[31:0];
+    X[rd+1] = data[63:32];
+  }
+sail(): |
+  let eff_addr = X(rs1') + (zero_extend(offset) << 3);
+  let data : bits(64) = MEM_read(64, eff_addr);
+
+  X(rd')   = data[31..0];
+  X(rd'+1) = data[63..32];

arch/inst/Zclsd/c.ldsp.yaml

@@ -0,0 +1,52 @@
+# yaml-language-server: $schema=../../../schemas/inst_schema.json
+
+$schema: "inst_schema.json#"
+kind: instruction
+name: c.ldsp
+long_name: Stack-pointer based load doubleword to even/odd register pair
+description: |
+  Loads stack-pointer relative 64-bit value into registers rd' and rd'+1. It computes its effective
+  address by adding the zero-extended offset, scaled by 8, to the stack pointer, x2. It expands to ld
+  rd, offset(x2). C.LDSP is only valid when rd≠x0; the code points with rd=x0 are reserved.
+definedBy:
+  anyOf: [Zclsd]
+assembly: ld rd, offset(rs1)
+encoding:
+  match: 011-----------01
+  variables:
+    - name: rd
+      location: 11-7
+    - name: imm
+      location: 12|6-2
+access:
+  s: always
+  u: always
+  vs: always
+  vu: always
+operation(): |
+
+  Bits<XLEN> base = X[2];
+  Bits<XLEN> offset = imm << 3;
+  Bits<XLEN> eff_addr = base + offset;
+
+  Bits<64> data = read_memory<64>(eff_addr, $encoding);
+
+  if (rd != 0 && (rd & 0x1) == 0) {
+    X[rd]   = data[31:0];
+    X[rd+1] = data[63:32];
+
+    }
+sail(): |
+  let imm : xlenbits = zero_extend(imm_field) << 3;
+  let ea  : xlenbits = X(2) + imm;
+
+  let data_low  : xlenbits = read_mem(ea, 32);
+  let data_high : xlenbits = read_mem(ea + 4, 32);
+  let data : bits(64) = data_high @ data_low;
+
+  if rd ≠ 0 & rd mod 2 == 0 & rd < 31 then {
+    X(rd)   = data[31..0];
+    X(rd+1) = data[63..32];
+  };
+
+  PC = PC + 2;

arch/inst/Zclsd/c.sd.yaml

@@ -0,0 +1,45 @@
+# yaml-language-server: $schema=../../../schemas/inst_schema.json
+
+$schema: "inst_schema.json#"
+kind: instruction
+name: c.sd
+long_name: Store doubleword from even/odd register pair
+description: |
+  Stores a 64-bit value from registers rs2' and rs2'+1. It computes an effective address by adding
+  the zero-extended offset, scaled by 8, to the base address in register rs1'. It expands to sd rs2',
+  offset(rs1').
+definedBy:
+  anyOf: [Zclsd]
+assembly: c.sd rs2', offset(rs1')
+encoding:
+  match: 111-----------00
+  variables:
+    - name: rs2
+      location: 4-2
+    - name: rs1
+      location: 9-7
+    - name: imm
+      location: 12-10|6-5
+access:
+  s: always
+  u: always
+  vs: always
+  vu: always
+operation(): |
+
+  Bits<XLEN> base = X[rs1];
+  Bits<XLEN> offset = imm << 3;
+  Bits<XLEN> eff_addr = base + offset;
+
+  Bits<64> data = {X[rs2+1], X[rs2]};
+
+  write_memory<64>(eff_addr, data, $encoding);
+
+sail(): |
+  let base = X(2);
+    let offset = zero_extend(imm) << 3;
+    let eff_addr = base + offset;
+
+    let data : bits(64) = X(rs2 + 1) @ X(rs2);
+
+    MEM_write(64, eff_addr, data);

arch/inst/Zclsd/c.sdsp.yaml

@@ -0,0 +1,43 @@
+# yaml-language-server: $schema=../../../schemas/inst_schema.json
+
+$schema: "inst_schema.json#"
+kind: instruction
+name: c.sdsp
+long_name: Stack-pointer based store doubleword from even/odd register pair
+description: |
+  Stores a stack-pointer relative 64-bit value from registers rs2' and rs2'+1. It computes an effective
+  address by adding the zero-extended offset, scaled by 8, to the stack pointer, x2. It expands to sd
+  rs2, offset(x2).
+definedBy:
+  anyOf: [Zclsd]
+assembly: c.sdsp rs2, offset(sp)
+encoding:
+  match: 111-----------10
+  variables:
+    - name: rs2
+      location: 6-2
+    - name: imm
+      location: 12-7
+access:
+  s: always
+  u: always
+  vs: always
+  vu: always
+operation(): |
+
+  Bits<XLEN> base = X[2];
+  Bits<XLEN> offset = imm << 3;
+  Bits<XLEN> eff_addr = base + offset;
+
+  Bits<64> data = {X[rs2+1], X[rs2]};
+
+  write_memory<64>(eff_addr, data, $encoding);
+
+sail(): |
+  let base = X(2);
+    let offset = zero_extend(imm) << 3;
+    let eff_addr = base + offset;
+
+    let data : bits(64) = X(rs2 + 1) @ X(rs2);
+
+    MEM_write(64, eff_addr, data);