core/vm: implement full EOF suite [WiP]

accounts/abi/bind/backends/simulated_test.go

@@ -495,7 +495,7 @@ func TestSimulatedBackend_EstimateGas(t *testing.T) {
 			GasPrice: u256.Num0,
 			Value:    nil,
 			Data:     common.Hex2Bytes("b9b046f9"),
-		}, 0, errors.New("invalid opcode: opcode 0xfe not defined"), nil},
+		}, 0, errors.New("invalid opcode: INVALID"), nil},
 
 		{"Valid", ethereum.CallMsg{
 			From:     addr,

core/vm/absint_cfg_proof_check.go

@@ -9,8 +9,6 @@ import (
 )
 
 type CfgOpSem struct {
-	reverts  bool
-	halts    bool
 	isPush   bool
 	isDup    bool
 	isSwap   bool
@@ -32,8 +30,6 @@ func NewCfgAbsSem() *CfgAbsSem {
 			continue
 		}
 		opsem := CfgOpSem{}
-		opsem.reverts = op.reverts
-		opsem.halts = op.halts
 		opsem.isPush = op.isPush
 		opsem.isDup = op.isDup
 		opsem.isSwap = op.isSwap
@@ -87,7 +83,7 @@ func resolveCheck(sem *CfgAbsSem, code []byte, st0 *astate, pc0 int) (map[int]bo
 	succs := make(map[int]bool)
 	jumps := make(map[int]bool)
 
-	if opsem == nil || opsem.halts || opsem.reverts {
+	if opsem == nil {
 		return succs, jumps, nil
 	}
 
@@ -98,7 +94,7 @@ func resolveCheck(sem *CfgAbsSem, code []byte, st0 *astate, pc0 int) (map[int]bo
 			if stack.hasIndices(0) {
 				jumpDest := stack.values[0]
 				if jumpDest.kind == InvalidValue {
-					//program terminates, don't add edges
+					// program terminates, don't add edges
 				} else if jumpDest.kind == TopValue {
 					empty := make(map[int]bool)
 					return empty, empty, errors.New("unresolvable jumps found")
@@ -113,7 +109,7 @@ func resolveCheck(sem *CfgAbsSem, code []byte, st0 *astate, pc0 int) (map[int]bo
 		}
 	}
 
-	//fall-thru edge
+	// fall-thru edge
 	if opcode != JUMP {
 		if pc0 < codeLen-opsem.numBytes {
 			succs[pc0+opsem.numBytes] = true

core/vm/absint_cfg_proof_gen.go

@@ -87,7 +87,7 @@ func toProgram(code []byte) *Program {
 		op := OpCode(code[pc])
 		stmt.opcode = op
 		stmt.operation = jt[op]
-		stmt.ends = stmt.operation == nil || stmt.operation.halts || stmt.operation.reverts
+		stmt.ends = stmt.operation == nil
 		//fmt.Printf("%v %v %v", pc, stmt.opcode, stmt.operation.valid)
 
 		if op.IsPush() {

core/vm/analysis.go

@@ -26,6 +26,20 @@ func codeBitmap(code []byte) []uint64 {
 	for pc := 0; pc < len(code); {
 		op := OpCode(code[pc])
 		pc++
+		// Short circruit for now on EOF ops with immediates.
+		// TODO(matt): make EOF-specific code bitmap
+		if op == RJUMP || op == RJUMPI || op == CALLF {
+			// TODO(CZ): For now the logic of bitvec.setN has been copied
+			// and modified to work with a uint64 slice instead of a bitvec.
+			// https://github.dev/lightclient/go-ethereum/blob/b3f36e10766956bf204f2d2b9415dcd8cfd2be6b/core/vm/analysis.go#L37
+
+			// Also applied @holiman suggestion in order to make legacy code tests work.
+			// https://github.com/ethereum/go-ethereum/pull/26133/files#r1026320917
+			bits[pc/64] |= 1 << (uint64(pc) & 63)
+			pc += 2
+
+			continue
+		}
 		if op >= PUSH1 && op <= PUSH32 {
 			numbits := int(op - PUSH1 + 1)
 			x := uint64(1) << (op - PUSH1)

core/vm/contract.go

@@ -48,14 +48,16 @@ type Contract struct {
 	CallerAddress common.Address
 	caller        ContractRef
 	self          ContractRef
-	jumpdests     map[common.Hash][]uint64 // Aggregated result of JUMPDEST analysis.
-	analysis      []uint64                 // Locally cached result of JUMPDEST analysis
-	skipAnalysis  bool
 
-	Code     []byte
-	CodeHash common.Hash
-	CodeAddr *common.Address
-	Input    []byte
+	jumpdests    map[common.Hash][]uint64 // Aggregated result of JUMPDEST analysis.
+	analysis     []uint64                 // Locally cached result of JUMPDEST analysis
+	skipAnalysis bool
+
+	Code      []byte
+	Container *EOF1Container
+	CodeHash  common.Hash
+	CodeAddr  *common.Address
+	Input     []byte
 
 	Gas   uint64
 	value *uint256.Int
@@ -109,6 +111,10 @@ func isCodeFromAnalysis(analysis []uint64, udest uint64) bool {
 // isCode returns true if the provided PC location is an actual opcode, as
 // opposed to a data-segment following a PUSHN operation.
 func (c *Contract) isCode(udest uint64) bool {
+	if !c.IsLegacy() {
+		// TODO remove this
+		panic("shouldn't run jumpdest analysis on EOF")
+	}
 	// Do we have a contract hash already?
 	// If we do have a hash, that means it's a 'regular' contract. For regular
 	// contracts ( not temporary initcode), we store the analysis in a map
@@ -149,7 +155,7 @@ func (c *Contract) AsDelegate() *Contract {
 	return c
 }
 
-// GetOp returns the n'th element in the contract's byte array
+// GetOp returns the n'th element in the contract's byte array.
 func (c *Contract) GetOp(n uint64) OpCode {
 	return OpCode(c.GetByte(n))
 }
@@ -163,6 +169,16 @@ func (c *Contract) GetByte(n uint64) byte {
 	return 0
 }
 
+// GetOpInSection returns the n'th element in the code sections's byte array.
+func (c *Contract) GetOpInSection(n uint64, s uint64) OpCode {
+	if n < uint64(c.Container.codeSize[s]) {
+		code := c.Container.CodeAt(s)
+		return OpCode(code[n])
+	}
+
+	return STOP
+}
+
 // Caller returns the caller of the contract.
 //
 // Caller will recursively call caller when the contract is a delegate
@@ -190,18 +206,25 @@ func (c *Contract) Value() *uint256.Int {
 	return c.value
 }
 
+// IsLegacy returns true if contract is not EOF
+func (c *Contract) IsLegacy() bool {
+	return c.Container == nil
+}
+
 // SetCallCode sets the code of the contract and address of the backing data
 // object
-func (c *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte) {
+func (c *Contract) SetCallCode(addr *common.Address, hash common.Hash, code []byte, container *EOF1Container) {
 	c.Code = code
+	c.Container = container
 	c.CodeHash = hash
 	c.CodeAddr = addr
 }
 
 // SetCodeOptionalHash can be used to provide code, but it's optional to provide hash.
 // In case hash is not provided, the jumpdest analysis will not be saved to the parent context
-func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash) {
+func (c *Contract) SetCodeOptionalHash(addr *common.Address, codeAndHash *codeAndHash, container *EOF1Container) {
 	c.Code = codeAndHash.code
+	c.Container = container
 	c.CodeHash = codeAndHash.hash
 	c.CodeAddr = addr
 }

core/vm/eips.go

@@ -34,6 +34,10 @@ var activators = map[int]func(*JumpTable){
 	2200: enable2200,
 	1884: enable1884,
 	1344: enable1344,
+	3540: enable3540,
+	3670: enable3670,
+	4200: enable4200,
+	4750: enable4750,
 }
 
 // EnableEIP enables the given EIP on the config.
@@ -197,3 +201,133 @@ func enable3860(jt *JumpTable) {
 	jt[CREATE].dynamicGas = gasCreateEip3860
 	jt[CREATE2].dynamicGas = gasCreate2Eip3860
 }
+
+func enable3540(jt *JumpTable) {
+	// Do nothing.
+}
+
+func enable3670(jt *JumpTable) {
+	// Do nothing.
+}
+
+// enable4200 applies EIP-4200 (RJUMP and RJUMPI opcodes)
+func enable4200(jt *JumpTable) {
+	jt[RJUMP] = &operation{
+		execute:     opRjump,
+		constantGas: GasFastStep,
+		minStack:    minStack(0, 0),
+		maxStack:    maxStack(0, 0),
+		eof1Only:    true,
+	}
+	jt[RJUMPI] = &operation{
+		execute:     opRjumpi,
+		constantGas: GasFastishStep,
+		minStack:    minStack(1, 1),
+		maxStack:    maxStack(1, 1),
+		eof1Only:    true,
+	}
+}
+
+// opRjump implements the RJUMP opcode
+func opRjump(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
+	var (
+		code = scope.Contract.Container.CodeAt(scope.ActiveSection)
+		idx  = *pc + 1
+	)
+
+	relativeOffset, err := parseArg(code[idx : idx+2])
+	if err != nil {
+		return nil, err
+	}
+
+	// Move PC past the RJUMP instruction and its immediate argument.
+	*pc += 2 + 1
+
+	// Calculate the new PC given the relative offset. Already validated,
+	// so no need to verify casts.
+	*pc = uint64(int64(*pc)+int64(relativeOffset)) - 1 // pc will also be increased by interpreter loop
+
+	return nil, nil
+}
+
+// opRjumpi implements the RJUMPI opcode
+func opRjumpi(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
+	condition := scope.Stack.Pop()
+	if condition.BitLen() == 0 {
+		// Not branching, just skip over immediate argument.
+		*pc += 2
+		return nil, nil
+	}
+	return opRjump(pc, interpreter, scope)
+}
+
+// enable4750 applies EIP-4750 (CALLF and RETF opcodes)
+func enable4750(jt *JumpTable) {
+	jt[JUMP].legacyOnly = true
+	jt[JUMPI].legacyOnly = true
+	jt[CALLF] = &operation{
+		execute:     opCallf,
+		constantGas: GasMidStep,
+		minStack:    minStack(0, 0),
+		maxStack:    maxStack(0, 0),
+		eof1Only:    true,
+	}
+	jt[RETF] = &operation{
+		execute:     opRetf,
+		constantGas: GasMidStep,
+		minStack:    minStack(0, 0),
+		maxStack:    maxStack(0, 0),
+		eof1Only:    true,
+	}
+}
+
+// opCallf implements the CALLF opcode.
+func opCallf(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
+	var (
+		code = scope.Contract.Container.CodeAt(scope.ActiveSection)
+		idx  = *pc + 1
+	)
+	section, err := parseArg(code[idx : idx+2])
+	if err != nil {
+		return nil, err
+	}
+	caller := scope.RetStack[len(scope.RetStack)-1]
+	sig := scope.Contract.Container.types[int(section)]
+	if scope.Stack.Len() < int(caller.StackHeight)+int(sig.Input) {
+		return nil, fmt.Errorf("too few stack items")
+	}
+	if len(scope.RetStack) >= 1024 {
+		return nil, fmt.Errorf("return stack too deep")
+	}
+	context := &SubroutineContext{
+		Section:     scope.ActiveSection,
+		StackHeight: caller.StackHeight + uint64(scope.Stack.Len()),
+		Pc:          *pc,
+	}
+	scope.RetStack = append(scope.RetStack, context)
+
+	*pc = 0
+	*pc -= 1 // hacks xD
+	scope.ActiveSection = uint64(section)
+	scope.Stack.Floor = int(context.StackHeight)
+
+	return nil, nil
+}
+
+// opRetf implements the RETF opcode.
+func opRetf(pc *uint64, interpreter *EVMInterpreter, scope *ScopeContext) ([]byte, error) {
+	sig := scope.Contract.Container.types[scope.ActiveSection]
+	if scope.Stack.Len() < int(sig.Output) {
+		return nil, fmt.Errorf("too few stack items")
+	}
+
+	last := len(scope.RetStack) - 1
+	context := scope.RetStack[last]
+	scope.RetStack = scope.RetStack[:last]
+
+	*pc = context.Pc - 1
+	scope.ActiveSection = context.Section
+	scope.Stack.Floor = int(context.StackHeight)
+
+	return nil, nil
+}