UknownValue constant

NethermindEth · Sep 29, 2023 · 7ba7469 · 7ba7469
1 parent 6f305c4
commit 7ba7469
Show file tree

Hide file tree

Showing 3 changed files with 23 additions and 21 deletions.
diff --git a/pkg/runners/zero/zero.go b/pkg/runners/zero/zero.go
@@ -74,11 +74,11 @@ func (runner *ZeroRunner) InitializeMainEntrypoint() (memory.MemoryAddress, erro
 	if runner.proofmode {
 		startPc, ok := runner.program.Labels["__start__"]
 		if !ok {
-			return memory.MemoryAddress{}, errors.New("start label not found. Try compiling with `--proof_mode`")
+			return memory.UnknownValue, errors.New("start label not found. Try compiling with `--proof_mode`")
 		}
 		endPc, ok := runner.program.Labels["__end__"]
 		if !ok {
-			return memory.MemoryAddress{}, errors.New("end label not found. Try compiling with `--proof_mode`")
+			return memory.UnknownValue, errors.New("end label not found. Try compiling with `--proof_mode`")
 		}
 
 		offset := runner.segments()[VM.ExecutionSegment].Len()
@@ -94,14 +94,14 @@ func (runner *ZeroRunner) InitializeMainEntrypoint() (memory.MemoryAddress, erro
 			&dummyFPValue,
 		)
 		if err != nil {
-			return memory.MemoryAddress{}, err
+			return memory.UnknownValue, err
 		}
 
 		dummyPCValue := memory.MemoryValueFromUint[uint64](0)
 		// set dummy pc value
 		err = runner.memory().Write(VM.ExecutionSegment, offset+1, &dummyPCValue)
 		if err != nil {
-			return memory.MemoryAddress{}, err
+			return memory.UnknownValue, err
 		}
 
 		runner.vm.Context.Pc = memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: startPc}
@@ -127,23 +127,23 @@ func (runner *ZeroRunner) InitializeEntrypoint(
 		v := memory.MemoryValueFromFieldElement(arguments[i])
 		err := runner.memory().Write(VM.ExecutionSegment, uint64(i), &v)
 		if err != nil {
-			return memory.MemoryAddress{}, err
+			return memory.UnknownValue, err
 		}
 	}
 	offset := runner.segments()[VM.ExecutionSegment].Len()
 	err := runner.memory().Write(VM.ExecutionSegment, offset, returnFp)
 	if err != nil {
-		return memory.MemoryAddress{}, err
+		return memory.UnknownValue, err
 	}
 	endMV := memory.MemoryValueFromMemoryAddress(&end)
 	err = runner.memory().Write(VM.ExecutionSegment, offset+1, &endMV)
 	if err != nil {
-		return memory.MemoryAddress{}, err
+		return memory.UnknownValue, err
 	}
 
 	pc, ok := runner.program.Entrypoints[funcName]
 	if !ok {
-		return memory.MemoryAddress{}, fmt.Errorf("unknwon entrypoint: %s", funcName)
+		return memory.UnknownValue, fmt.Errorf("unknwon entrypoint: %s", funcName)
 	}
 
 	runner.vm.Context.Pc = memory.MemoryAddress{SegmentIndex: VM.ProgramSegment, Offset: pc}

diff --git a/pkg/vm/memory/memory_value.go b/pkg/vm/memory/memory_value.go
@@ -16,6 +16,8 @@ type MemoryAddress struct {
 	Offset       uint64
 }
 
+var UnknownValue = MemoryAddress{}
+
 func (address *MemoryAddress) Equal(other *MemoryAddress) bool {
 	return address.SegmentIndex == other.SegmentIndex && address.Offset == other.Offset
 }
@@ -179,7 +181,7 @@ func (mv *MemoryValue) ToMemoryAddress() (*MemoryAddress, error) {
 }
 
 func (mv *MemoryValue) ToFieldElement() (*f.Element, error) {
-	if !mv.isFelt {
+	if mv.isFelt == false {
 		return nil, fmt.Errorf("memory value is not a field element")
 	}
 	return &mv.felt, nil

diff --git a/pkg/vm/vm.go b/pkg/vm/vm.go
@@ -235,7 +235,7 @@ func (vm *VirtualMachine) getDstAddr(instruction *Instruction) (mem.MemoryAddres
 
 	addr, isOverflow := safemath.SafeOffset(dstRegister, instruction.OffDest)
 	if isOverflow {
-		return mem.MemoryAddress{}, fmt.Errorf("offset overflow: %d + %d", dstRegister, instruction.OffDest)
+		return mem.UnknownValue, fmt.Errorf("offset overflow: %d + %d", dstRegister, instruction.OffDest)
 	}
 	return mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: addr}, nil
 }
@@ -250,7 +250,7 @@ func (vm *VirtualMachine) getOp0Addr(instruction *Instruction) (mem.MemoryAddres
 
 	addr, isOverflow := safemath.SafeOffset(op0Register, instruction.OffOp0)
 	if isOverflow {
-		return mem.MemoryAddress{}, fmt.Errorf("offset overflow: %d + %d", op0Register, instruction.OffOp0)
+		return mem.UnknownValue, fmt.Errorf("offset overflow: %d + %d", op0Register, instruction.OffOp0)
 	}
 	return mem.MemoryAddress{SegmentIndex: ExecutionSegment, Offset: addr}, nil
 }
@@ -262,12 +262,12 @@ func (vm *VirtualMachine) getOp1Addr(instruction *Instruction, op0Addr *mem.Memo
 		// in this case Op0 is being used as an address, and must be of unwrapped as it
 		op0Value, err := vm.MemoryManager.Memory.ReadFromAddress(op0Addr)
 		if err != nil {
-			return mem.MemoryAddress{}, fmt.Errorf("cannot read op0: %w", err)
+			return mem.UnknownValue, fmt.Errorf("cannot read op0: %w", err)
 		}
 
 		op0Address, err := op0Value.ToMemoryAddress()
 		if err != nil {
-			return mem.MemoryAddress{}, fmt.Errorf("op0 is not an address: %w", err)
+			return mem.UnknownValue, fmt.Errorf("op0 is not an address: %w", err)
 		}
 		op1Address = mem.MemoryAddress{SegmentIndex: op0Address.SegmentIndex, Offset: op0Address.Offset}
 	case Imm:
@@ -280,7 +280,7 @@ func (vm *VirtualMachine) getOp1Addr(instruction *Instruction, op0Addr *mem.Memo
 
 	addr, isOverflow := safemath.SafeOffset(op1Address.Offset, instruction.OffOp1)
 	if isOverflow {
-		return mem.MemoryAddress{}, fmt.Errorf("offset overflow: %d + %d", op1Address.Offset, instruction.OffOp1)
+		return mem.UnknownValue, fmt.Errorf("offset overflow: %d + %d", op1Address.Offset, instruction.OffOp1)
 	}
 	op1Address.Offset = addr
 	return op1Address, nil
@@ -425,26 +425,26 @@ func (vm *VirtualMachine) updatePc(
 	case Jump:
 		addr, err := res.ToMemoryAddress()
 		if err != nil {
-			return mem.MemoryAddress{}, fmt.Errorf("absolute jump: %w", err)
+			return mem.UnknownValue, fmt.Errorf("absolute jump: %w", err)
 		}
 		return *addr, nil
 	case JumpRel:
 		val, err := res.ToFieldElement()
 		if err != nil {
-			return mem.MemoryAddress{}, fmt.Errorf("relative jump: %w", err)
+			return mem.UnknownValue, fmt.Errorf("relative jump: %w", err)
 		}
 		newPc := vm.Context.Pc
 		err = newPc.Add(&newPc, val)
 		return newPc, err
 	case Jnz:
 		destMv, err := vm.MemoryManager.Memory.ReadFromAddress(dstAddr)
 		if err != nil {
-			return mem.MemoryAddress{}, err
+			return mem.UnknownValue, err
 		}
 
 		dest, err := destMv.ToFieldElement()
 		if err != nil {
-			return mem.MemoryAddress{}, err
+			return mem.UnknownValue, err
 		}
 
 		if dest.IsZero() {
@@ -456,20 +456,20 @@ func (vm *VirtualMachine) updatePc(
 
 		op1Mv, err := vm.MemoryManager.Memory.ReadFromAddress(op1Addr)
 		if err != nil {
-			return mem.MemoryAddress{}, err
+			return mem.UnknownValue, err
 		}
 
 		val, err := op1Mv.ToFieldElement()
 		if err != nil {
-			return mem.MemoryAddress{}, err
+			return mem.UnknownValue, err
 		}
 
 		newPc := vm.Context.Pc
 		err = newPc.Add(&newPc, val)
 		return newPc, err
 
 	}
-	return mem.MemoryAddress{}, fmt.Errorf("unkwon pc update value: %d", instruction.PcUpdate)
+	return mem.UnknownValue, fmt.Errorf("unkwon pc update value: %d", instruction.PcUpdate)
 }
 
 func (vm *VirtualMachine) updateAp(instruction *Instruction, res *mem.MemoryValue) (uint64, error) {