Finish adaption to yarc bn-in-fn.

bv/bitVector.go

@@ -20,8 +20,8 @@ func Bv(width uint) BitVector {
  return newBv
 }
 
-func (bv BitVector) ToUint64() uint64 {
- var n uint64
+func (bv BitVector) ToUint32() uint32 {
+ var n uint32
  for i := len(bv.bits) - 1; i >= 0; i-- {
  n <<= 1
  if bv.bits[i] {
@@ -97,21 +97,19 @@ func (bv BitVector) Equal(_bv BitVector, strict bool) bool {
 }
 
 func (bv *BitVector) From(i interface{}) {
- var _i uint64
+ var _i uint32
  switch v := i.(type) {
  case uint16:
- _i = uint64(v)
+ _i = uint32(v)
  case int:
- _i = uint64(uint(v))
+ _i = uint32(uint(v))
  case uint32:
- _i = uint64(v)
- case uint64:
  _i = v
  case bool:
  bv.bits[0] = v
  return
  default:
- log.Panicf("Unable to convert %T to uint64.\n", i)
+ log.Panicf("Unable to convert %T to uint32.\n", i)
  }
  var j uint32
  for j = 0; j < uint32(len(bv.bits)); j++ {
@@ -158,7 +156,7 @@ func (bv BitVector) String() string {
 // w = 8
 // }
 // format := fmt.Sprintf("0x%%0%dX of width %%d", w)
-// return fmt.Sprintf(format, bv.ToUint64(), bv.Width)
+// return fmt.Sprintf(format, bv.ToUint32(), bv.Width)
 //}
 
 func B(s string) BitVector {

instruction/add.go

@@ -12,14 +12,14 @@ var ADD = Instruction{
  pattern: bv.P("0000000 XXXXX XXXXX 000 XXXXX 0110011"),
  operation: func(_inst *Instruction) {
  log.Printf("Decoding as ADD x%d, x%d, x%d",
- _inst.rd.ToUint64(),
- _inst.rs1.ToUint64(),
- _inst.rs2.ToUint64())
+ _inst.rd.ToUint32(),
+ _inst.rs1.ToUint32(),
+ _inst.rs2.ToUint32())
 
  op1 := _inst.p.ReadReg(_inst.rs1) // first operator of alu
  op2 := _inst.p.ReadReg(_inst.rs2) // second operator of alu
- result := bv.Bv(64) // will hold the result of alu
- result.From(op1.ToUint64() + op2.ToUint64()) // perform computation
+ result := bv.Bv(32) // will hold the result of alu
+ result.From(op1.ToUint32() + op2.ToUint32()) // perform computation
  _inst.p.WriteReg(_inst.rd, result) // write result back to rd
  },
 }

instruction/addi.go

@@ -12,14 +12,14 @@ var ADDI = Instruction{
  pattern: bv.P("XXXXXXXXXXXX XXXXX 000 XXXXX 0010011"),
  operation: func(_inst *Instruction) {
  log.Printf("Decoding as ADDI x%d, x%d, %d",
- _inst.rd.ToUint64(),
- _inst.rs1.ToUint64(),
- int64(_inst.iImm.SignExtendTo(64).ToUint64()))
+ _inst.rd.ToUint32(),
+ _inst.rs1.ToUint32(),
+ int32(_inst.iImm.SignExtendTo(32).ToUint32()))
 
  op1 := _inst.p.ReadReg(_inst.rs1) // first operator of alu
- op2 := _inst.iImm.SignExtendTo(64) // second operator of alu
- result := bv.Bv(64) // will hold the result of alu
- result.From(op1.ToUint64() + op2.ToUint64()) // perform computation
+ op2 := _inst.iImm.SignExtendTo(32) // second operator of alu
+ result := bv.Bv(32) // will hold the result of alu
+ result.From(op1.ToUint32() + op2.ToUint32()) // perform computation
  _inst.p.WriteReg(_inst.rd, result) // write result back to rd
  },
 }

instruction/and.go

@@ -11,14 +11,14 @@ var AND = Instruction{
  pattern: bv.P("0000000 XXXXX XXXXX 111 XXXXX 0110011"),
  operation: func(_inst *Instruction) {
  log.Printf("Decoding as AND x%d, x%d, x%d",
- _inst.rd.ToUint64(),
- _inst.rs1.ToUint64(),
- _inst.rs2.ToUint64())
+ _inst.rd.ToUint32(),
+ _inst.rs1.ToUint32(),
+ _inst.rs2.ToUint32())
 
  op1 := _inst.p.ReadReg(_inst.rs1) // first operator of alu
  op2 := _inst.p.ReadReg(_inst.rs2) // second operator of alu
- result := bv.Bv(64) // will hold the result of alu
- result.From(op1.ToUint64() & op2.ToUint64()) // perform computation
+ result := bv.Bv(32) // will hold the result of alu
+ result.From(op1.ToUint32() & op2.ToUint32()) // perform computation
  _inst.p.WriteReg(_inst.rd, result) // write result back to rd
  },
 }

instruction/andi.go

@@ -12,14 +12,14 @@ var ANDI = Instruction{
  pattern: bv.P("XXXXXXXXXXXX XXXXX 111 XXXXX 0010011"),
  operation: func(_inst *Instruction) {
  log.Printf("Decoding as ANDI x%d, x%d, %d",
- _inst.rd.ToUint64(),
- _inst.rs1.ToUint64(),
- _inst.iImm.SignExtendTo(64).ToUint64())
+ _inst.rd.ToUint32(),
+ _inst.rs1.ToUint32(),
+ _inst.iImm.SignExtendTo(32).ToUint32())
 
  op1 := _inst.p.ReadReg(_inst.rs1) // first operator of alu
- op2 := _inst.iImm.SignExtendTo(64) // second operator of alu
- result := bv.Bv(64) // will hold the result of alu
- result.From(op1.ToUint64() & op2.ToUint64()) // perform computation
+ op2 := _inst.iImm.SignExtendTo(32) // second operator of alu
+ result := bv.Bv(32) // will hold the result of alu
+ result.From(op1.ToUint32() & op2.ToUint32()) // perform computation
  _inst.p.WriteReg(_inst.rd, result) // write result back to rd
  },
 }

instruction/auipc.go

@@ -11,14 +11,14 @@ var AUIPC = Instruction{
  name: "AUIPC",
  pattern: bv.P("XXXXXXXXXXXXXXXXXXXX XXXXX 0010111"),
  operation: func(_inst *Instruction) {
- op1 := bv.Cat(_inst.uImm, bv.B("0000 0000 0000")).SignExtendTo(64) // appends 12 low-order zero bits to the 20-bit U-immediate and sign extends to 64 bit
+ op1 := bv.Cat(_inst.uImm, bv.B("0000 0000 0000"))
 
  log.Printf("Decoding as AUIPC x%d, %d",
- _inst.rd.ToUint64(),
- _inst.uImm.ToUint64())
+ _inst.rd.ToUint32(),
+ _inst.uImm.ToUint32())
 
- result := bv.Bv(64) // will hold the result
- result.From(op1.ToUint64() + _inst.p.ReadPc().ToUint64()) // adds op1 to the pc
+ result := bv.Bv(32) // will hold the result
+ result.From(op1.ToUint32() + _inst.p.ReadPc().ToUint32()) // adds op1 to the pc
  _inst.p.WriteReg(_inst.rd, result) // places the result in register rd
  },
 }