add activation flag for bulk mem opcodes

laurci · laurci · commit 8a392f5c4baf · 2025-08-20T15:26:37.000+03:00
diff --git a/executor/executorInstance.go b/executor/executorInstance.go
@@ -20,6 +20,7 @@ type Instance interface {
 	MemGrow(pages uint32) error
 	MemDump() []byte
 	IsFunctionImported(name string) bool
+	IsOpcodeUsed(opcode OpcodeUsed) bool
 	IsInterfaceNil() bool
 	Reset() bool
 	SetVMHooksPtr(vmHooksPtr uintptr)
diff --git a/executor/executorUsedOpcode.go b/executor/executorUsedOpcode.go
@@ -0,0 +1,8 @@
+package executor
+
+type OpcodeUsed uint32
+
+const (
+	OpcodeUsedMemoryCopy OpcodeUsed = iota
+	OpcodeUsedMemoryFill
+)
diff --git a/executor/wrapper/wrapperInstance.go b/executor/wrapper/wrapperInstance.go
@@ -131,6 +131,12 @@ func (inst *WrapperInstance) IsFunctionImported(name string) bool {
 	return result
 }
 
+// IsOpcodeUsed wraps the call to the underlying instance.
+func (inst *WrapperInstance) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	result := inst.wrappedInstance.IsOpcodeUsed(opcode)
+	return result
+}
+
 // IsInterfaceNil returns true if there is no value under the interface.
 func (inst *WrapperInstance) IsInterfaceNil() bool {
 	return inst == nil
diff --git a/mock/context/instanceMock.go b/mock/context/instanceMock.go
@@ -20,6 +20,7 @@ type InstanceMock struct {
 	Exports         map[string]string
 	DefaultErrors   map[string]error
 	Methods         map[string]mockMethod
+	OpcodeUsed      map[executor.OpcodeUsed]bool
 	Points          uint64
 	Data            executor.VMHooks
 	GasLimit        uint64
@@ -183,6 +184,12 @@ func (instance *InstanceMock) IsFunctionImported(name string) bool {
 	return ok
 }
 
+// IsOpcodeUsed mocked method
+func (instance *InstanceMock) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	used, ok := instance.OpcodeUsed[opcode]
+	return ok && used
+}
+
 // GetMockInstance gets the mock instance from the runtime of the provided host
 func GetMockInstance(host vmhost.VMHost) *InstanceMock {
 	instance := host.Runtime().GetInstance().(*InstanceMock)
diff --git a/mock/context/runtimeContextMock.go b/mock/context/runtimeContextMock.go
@@ -332,6 +332,11 @@ func (r *RuntimeContextMock) IsFunctionImported(_ string) bool {
 	return true
 }
 
+// IsOpcodeUsed mocked method
+func (r *RuntimeContextMock) IsOpcodeUsed(_ executor.OpcodeUsed) bool {
+	return false
+}
+
 // AddError mocked method
 func (r *RuntimeContextMock) AddError(_ error, _ ...string) {
 }
diff --git a/mock/context/runtimeContextWrapper.go b/mock/context/runtimeContextWrapper.go
@@ -68,6 +68,8 @@ type RuntimeContextWrapper struct {
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	IsFunctionImportedFunc func(name string) bool
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
+	IsOpcodeUsedFunc func(opcode executor.OpcodeUsed) bool
+	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	ReadOnlyFunc func() bool
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	SetReadOnlyFunc func(readOnly bool)
@@ -216,6 +218,10 @@ func NewRuntimeContextWrapper(inputRuntimeContext *vmhost.RuntimeContext) *Runti
 		return runtimeWrapper.runtimeContext.IsFunctionImported(name)
 	}
 
+	runtimeWrapper.IsOpcodeUsedFunc = func(opcode executor.OpcodeUsed) bool {
+		return runtimeWrapper.runtimeContext.IsOpcodeUsed(opcode)
+	}
+
 	runtimeWrapper.ReadOnlyFunc = func() bool {
 		return runtimeWrapper.runtimeContext.ReadOnly()
 	}
@@ -419,6 +425,11 @@ func (contextWrapper *RuntimeContextWrapper) IsFunctionImported(name string) boo
 	return contextWrapper.IsFunctionImportedFunc(name)
 }
 
+// IsOpcodeUsed calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	return contextWrapper.IsOpcodeUsedFunc(opcode)
+}
+
 // ReadOnly calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
 func (contextWrapper *RuntimeContextWrapper) ReadOnly() bool {
 	return contextWrapper.ReadOnlyFunc()
diff --git a/mock/mockery/Instance.go b/mock/mockery/Instance.go
@@ -240,6 +240,24 @@ func (_m *MockInstance) IsFunctionImported(name string) bool {
 	return r0
 }
 
+// IsOpcodeUsed provides a mock function with given fields: opcode
+func (_m *MockInstance) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	ret := _m.Called(opcode)
+
+	if len(ret) == 0 {
+		return false
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(executor.OpcodeUsed) bool); ok {
+		r0 = rf(opcode)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
 // IsInterfaceNil provides a mock function with no fields
 func (_m *MockInstance) IsInterfaceNil() bool {
 	ret := _m.Called()
diff --git a/mock/mockery/RuntimeContext.go b/mock/mockery/RuntimeContext.go
@@ -562,6 +562,24 @@ func (_m *MockRuntimeContext) IsFunctionImported(name string) bool {
 	return r0
 }
 
+// IsOpcodeUsed provides a mock function with given fields: opcode
+func (_m *MockRuntimeContext) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	ret := _m.Called(opcode)
+
+	if len(ret) == 0 {
+		return false
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(executor.OpcodeUsed) bool); ok {
+		r0 = rf(opcode)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
 // IsReservedFunctionName provides a mock function with given fields: functionName
 func (_m *MockRuntimeContext) IsReservedFunctionName(functionName string) bool {
 	ret := _m.Called(functionName)
diff --git a/vmhost/contexts/runtime.go b/vmhost/contexts/runtime.go
@@ -704,6 +704,14 @@ func (context *runtimeContext) VerifyContractCode() error {
 		}
 	}
 
+	if !enableEpochsHandler.IsFlagEnabled(vmhost.AsyncV3Flag) {
+		err = context.checkIfContainsBulkMemoryOpcodes()
+		if err != nil {
+			logRuntime.Trace("verify contract code", "error", err)
+			return err
+		}
+	}
+
 	logRuntime.Trace("verified contract code")
 
 	return nil
@@ -727,6 +735,18 @@ func (context *runtimeContext) checkIfContainsBarnardOpcodes() error {
 	return nil
 }
 
+func (context *runtimeContext) checkIfContainsBulkMemoryOpcodes() error {
+	if context.iTracker.Instance().IsOpcodeUsed(executor.OpcodeUsedMemoryCopy) {
+		return vmhost.ErrContractInvalid
+	}
+
+	if context.iTracker.Instance().IsOpcodeUsed(executor.OpcodeUsedMemoryFill) {
+		return vmhost.ErrContractInvalid
+	}
+
+	return nil
+}
+
 // UseGasBoundedShouldFailExecution returns true when flag activated
 func (context *runtimeContext) UseGasBoundedShouldFailExecution() bool {
 	return context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.UseGasBoundedShouldFailExecutionFlag)
@@ -831,6 +851,11 @@ func (context *runtimeContext) IsFunctionImported(name string) bool {
 	return context.iTracker.Instance().IsFunctionImported(name)
 }
 
+// IsOpcodeUsed returns true if the WASM module uses the specified opcode.
+func (context *runtimeContext) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	return context.iTracker.Instance().IsOpcodeUsed(opcode)
+}
+
 // AddError adds an error to the global error list on runtime context
 func (context *runtimeContext) AddError(err error, otherInfo ...string) {
 	if err == nil {
diff --git a/vmhost/hosttest/forbidden_opcodes_test.go b/vmhost/hosttest/forbidden_opcodes_test.go
@@ -61,3 +61,38 @@ func TestBarnardOpcodesActivation(t *testing.T) {
 				ContractInvalid()
 		})
 }
+
+func TestBulkMemoryOpcodesActivation(t *testing.T) {
+	wasmModules := []string{"memory-copy", "memory-fill"}
+
+	for _, moduleName := range wasmModules {
+		testcommon.BuildInstanceCreatorTest(t).
+			WithInput(testcommon.CreateTestContractCreateInputBuilder().
+				WithGasProvided(100000000).
+				WithContractCode(testcommon.GetTestSCCodeModule("forbidden-opcodes/"+moduleName, moduleName, "../../")).
+				Build()).
+			WithEnableEpochsHandler(&worldmock.EnableEpochsHandlerStub{
+				IsFlagEnabledCalled: func(flag core.EnableEpochFlag) bool {
+					return flag != vmhost.AsyncV3Flag
+				},
+			}).
+			AndAssertResults(func(stubBlockchainHook *contextmock.BlockchainHookStub, verify *testcommon.VMOutputVerifier) {
+				verify.
+					ContractInvalid()
+			})
+
+		testcommon.BuildInstanceCreatorTest(t).
+			WithInput(testcommon.CreateTestContractCreateInputBuilder().
+				WithGasProvided(100000000).
+				WithContractCode(testcommon.GetTestSCCodeModule("forbidden-opcodes/"+moduleName, moduleName, "../../")).
+				Build()).
+			WithEnableEpochsHandler(&worldmock.EnableEpochsHandlerStub{
+				IsFlagEnabledCalled: func(flag core.EnableEpochFlag) bool {
+					return true
+				},
+			}).
+			AndAssertResults(func(stubBlockchainHook *contextmock.BlockchainHookStub, verify *testcommon.VMOutputVerifier) {
+				verify.FunctionNotFound()
+			})
+	}
+}
diff --git a/vmhost/interface.go b/vmhost/interface.go
@@ -142,6 +142,7 @@ type RuntimeContext interface {
 	GetInstanceStackSize() uint64
 	CountSameContractInstancesOnStack(address []byte) uint64
 	IsFunctionImported(name string) bool
+	IsOpcodeUsed(opcode executor.OpcodeUsed) bool
 	ReadOnly() bool
 	SetReadOnly(readOnly bool)
 	StartWasmerInstance(contract []byte, gasLimit uint64, newCode bool) error
diff --git a/wasmer2/bridge2.go b/wasmer2/bridge2.go
@@ -168,6 +168,13 @@ func cWasmerInstanceHasImportedFunction(
 	))
 }
 
+func cWasmerInstanceIsOpcodeUsed(instance *cWasmerInstanceT, opcode uint32) cInt {
+	return (cInt)(C.vm_exec_instance_is_opcode_used(
+		(*C.vm_exec_instance_t)(instance),
+		(C.uint32_t)(opcode),
+	))
+}
+
 func cWasmerInstanceExportedFunctionNamesLength(instance *cWasmerInstanceT) cInt {
 	return (cInt)(C.vm_exported_function_names_length(
 		(*C.vm_exec_instance_t)(instance),
diff --git a/wasmer2/libvmexeccapi.dylib b/wasmer2/libvmexeccapi.dylib
diff --git a/wasmer2/libvmexeccapi.h b/wasmer2/libvmexeccapi.h
@@ -456,6 +456,15 @@ int vm_exec_instance_has_function(vm_exec_instance_t *instance_ptr, const char *
 int vm_exec_instance_has_imported_function(vm_exec_instance_t *instance_ptr,
                                            const char *func_name_ptr);
 
+/**
+ * Checks whether the given opcode is used in the wasm module.
+ *
+ * # Safety
+ *
+ * C API function, works with raw object pointers.
+ */
+int vm_exec_instance_is_opcode_used(vm_exec_instance_t *instance_ptr, uint32_t opcode_value);
+
 /**
  * Gets a pointer to the beginning of the contiguous memory data
  * bytes.
diff --git a/wasmer2/libvmexeccapi.so b/wasmer2/libvmexeccapi.so
diff --git a/wasmer2/libvmexeccapi_arm.dylib b/wasmer2/libvmexeccapi_arm.dylib
diff --git a/wasmer2/libvmexeccapi_arm.so b/wasmer2/libvmexeccapi_arm.so
diff --git a/wasmer2/wasmer2Instance.go b/wasmer2/wasmer2Instance.go
@@ -122,6 +122,11 @@ func (instance *Wasmer2Instance) IsFunctionImported(name string) bool {
 	return result == 1
 }
 
+// IsOpcodeUsed returns true if the WASM module uses the specified opcode.
+func (instance *Wasmer2Instance) IsOpcodeUsed(opcode executor.OpcodeUsed) bool {
+	return cWasmerInstanceIsOpcodeUsed(instance.cgoInstance, uint32(opcode)) == 1
+}
+
 // CallFunction executes given function from loaded contract.
 func (instance *Wasmer2Instance) CallFunction(functionName string) error {
 	var wasmFunctionName = cCString(functionName)

Original file line number	Diff line number	Diff line change
`@@ -332,6 +332,11 @@ func (r *RuntimeContextMock) IsFunctionImported(_ string) bool {`
`332`	`332`	`return true`
`333`	`333`	`}`
`334`	`334`
	`335`	`+// IsOpcodeUsed mocked method`
	`336`	`+func (r *RuntimeContextMock) IsOpcodeUsed(_ executor.OpcodeUsed) bool {`
	`337`	`+ return false`
	`338`	`+}`
	`339`	`+`
`335`	`340`	`// AddError mocked method`
`336`	`341`	`func (r *RuntimeContextMock) AddError(_ error, _ ...string) {`
`337`	`342`	`}`