Merge pull request #788 from multiversx/merge_master_into_rc170_2023.…

…10.11

Merge master into rc170 2023.10.11

test/contracts/answer-locals/answer-locals.wat

@@ -2,12 +2,14 @@
   (type (;0;) (func (param i64)))
   (type (;1;) (func))
   (import "env" "int64finish" (func (;0;) (type 0)))
-  (func (;1;) (type 1)
-    (local i64 i64 i64 i64 i64)
+  (func (;1;) (type 1))
+  (func (;2;) (type 1)
+    (local i64 i64 i64 i64)
     i64.const 42
     call 0)
   (table (;0;) 1 1 funcref)
   (memory (;0;) 2)
   (global (;0;) (mut i32) (i32.const 66560))
   (export "memory" (memory 0))
-  (export "answer" (func 1)))
+  (export "init" (func 1))
+	(export "answer" (func 2)))

test/contracts/answer/answer.c

@@ -1,5 +1,7 @@
 #include "../mxvm/context.h"
 
+void init() {}
+
 void answer() {
 	int64finish(42);
 }

test/contracts/answer/answer.export

@@ -1 +1,2 @@
 answer
+init

test/contracts/counter/counter.c

@@ -7,6 +7,10 @@ void init() {
     int64storageStore(COUNTER_KEY, COUNTER_KEY_LEN, 1);
 }
 
+void upgrade() {
+    int64storageStore(COUNTER_KEY, COUNTER_KEY_LEN, 1);
+}
+
 void increment() {
     i64 counter = int64storageLoad(COUNTER_KEY, COUNTER_KEY_LEN);
     counter++;

test/contracts/counter/counter.export

@@ -1,4 +1,5 @@
 init
+upgrade
 increment
 decrement
 get

test/contracts/counter/output/counter.wat

@@ -1,56 +1,197 @@
 (module
-  (type $t0 (func (param i32 i32 i64) (result i32)))
-  (type $t1 (func (param i32 i32) (result i64)))
-  (type $t2 (func (param i64)))
-  (type $t3 (func))
-  (import "env" "int64storageStore" (func $env.int64storageStore (type $t0)))
-  (import "env" "int64storageLoad" (func $env.int64storageLoad (type $t1)))
-  (import "env" "int64finish" (func $env.int64finish (type $t2)))
-  (func $init (type $t3)
+  (type (;0;) (func (param i32 i32 i64) (result i32)))
+  (type (;1;) (func (param i32 i32) (result i64)))
+  (type (;2;) (func (param i64)))
+  (type (;3;) (func))
+  (import "env" "int64storageStore" (func (;0;) (type 0)))
+  (import "env" "int64storageLoad" (func (;1;) (type 1)))
+  (import "env" "int64finish" (func (;2;) (type 2)))
+  (func (;3;) (type 3)
+    (local i32 i32 i64)
     i32.const 1024
+    local.set 0
     i32.const 7
+    local.set 1
     i64.const 1
-    call $env.int64storageStore
-    drop)
-  (func $increment (type $t3)
-    (local $l0 i64)
+    local.set 2
+    local.get 0
+    local.get 1
+    local.get 2
+    call 0
+    drop
+    return)
+  (func (;4;) (type 3)
+    (local i32 i32 i64)
     i32.const 1024
+    local.set 0
     i32.const 7
+    local.set 1
+    i64.const 1
+    local.set 2
+    local.get 0
+    local.get 1
+    local.get 2
+    call 0
+    drop
+    return)
+  (func (;5;) (type 3)
+    (local i32 i32 i32 i32 i32 i64 i64 i64 i64 i64 i64 i32 i32)
+    global.get 0
+    local.set 0
+    i32.const 16
+    local.set 1
+    local.get 0
+    local.get 1
+    i32.sub
+    local.set 2
+    local.get 2
+    global.set 0
     i32.const 1024
+    local.set 3
     i32.const 7
-    call $env.int64storageLoad
+    local.set 4
+    local.get 3
+    local.get 4
+    call 1
+    local.set 5
+    local.get 2
+    local.get 5
+    i64.store offset=8
+    local.get 2
+    i64.load offset=8
+    local.set 6
     i64.const 1
+    local.set 7
+    local.get 6
+    local.get 7
     i64.add
-    local.tee $l0
-    call $env.int64storageStore
+    local.set 8
+    local.get 2
+    local.get 8
+    i64.store offset=8
+    local.get 2
+    i64.load offset=8
+    local.set 9
+    local.get 3
+    local.get 4
+    local.get 9
+    call 0
     drop
-    local.get $l0
-    call $env.int64finish)
-  (func $decrement (type $t3)
-    (local $l0 i64)
-    i32.const 1024
-    i32.const 7
+    local.get 2
+    i64.load offset=8
+    local.set 10
+    local.get 10
+    call 2
+    i32.const 16
+    local.set 11
+    local.get 2
+    local.get 11
+    i32.add
+    local.set 12
+    local.get 12
+    global.set 0
+    return)
+  (func (;6;) (type 3)
+    (local i32 i32 i32 i32 i32 i64 i64 i64 i64 i64 i64 i32 i32)
+    global.get 0
+    local.set 0
+    i32.const 16
+    local.set 1
+    local.get 0
+    local.get 1
+    i32.sub
+    local.set 2
+    local.get 2
+    global.set 0
     i32.const 1024
+    local.set 3
     i32.const 7
-    call $env.int64storageLoad
+    local.set 4
+    local.get 3
+    local.get 4
+    call 1
+    local.set 5
+    local.get 2
+    local.get 5
+    i64.store offset=8
+    local.get 2
+    i64.load offset=8
+    local.set 6
     i64.const -1
+    local.set 7
+    local.get 6
+    local.get 7
     i64.add
-    local.tee $l0
-    call $env.int64storageStore
+    local.set 8
+    local.get 2
+    local.get 8
+    i64.store offset=8
+    local.get 2
+    i64.load offset=8
+    local.set 9
+    local.get 3
+    local.get 4
+    local.get 9
+    call 0
     drop
-    local.get $l0
-    call $env.int64finish)
-  (func $get (type $t3)
+    local.get 2
+    i64.load offset=8
+    local.set 10
+    local.get 10
+    call 2
+    i32.const 16
+    local.set 11
+    local.get 2
+    local.get 11
+    i32.add
+    local.set 12
+    local.get 12
+    global.set 0
+    return)
+  (func (;7;) (type 3)
+    (local i32 i32 i32 i32 i32 i64 i64 i32 i32)
+    global.get 0
+    local.set 0
+    i32.const 16
+    local.set 1
+    local.get 0
+    local.get 1
+    i32.sub
+    local.set 2
+    local.get 2
+    global.set 0
     i32.const 1024
+    local.set 3
     i32.const 7
-    call $env.int64storageLoad
-    call $env.int64finish)
-  (table $T0 1 1 funcref)
-  (memory $memory 2)
-  (global $g0 (mut i32) (i32.const 66576))
+    local.set 4
+    local.get 3
+    local.get 4
+    call 1
+    local.set 5
+    local.get 2
+    local.get 5
+    i64.store offset=8
+    local.get 2
+    i64.load offset=8
+    local.set 6
+    local.get 6
+    call 2
+    i32.const 16
+    local.set 7
+    local.get 2
+    local.get 7
+    i32.add
+    local.set 8
+    local.get 8
+    global.set 0
+    return)
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) 2)
+  (global (;0;) (mut i32) (i32.const 66576))
   (export "memory" (memory 0))
-  (export "init" (func $init))
-  (export "increment" (func $increment))
-  (export "decrement" (func $decrement))
-  (export "get" (func $get))
-  (data $d0 (i32.const 1024) "COUNTER\00"))
+  (export "init" (func 3))
+  (export "upgrade" (func 4))
+  (export "increment" (func 5))
+  (export "decrement" (func 6))
+  (export "get" (func 7))
+  (data (;0;) (i32.const 1024) "COUNTER\00"))

vmhost/hostCore/execution.go

@@ -1150,7 +1150,7 @@ func (host *vmHost) callUpgradeFunction() error {
 func (host *vmHost) callSCFunction(functionName string) error {
 	runtime := host.Runtime()
 	if !runtime.HasFunction(functionName) {
-		return nil
+		return executor.ErrFuncNotFound
 	}
 
 	err := runtime.CallSCFunction(functionName)

vmhost/hosttest/bad_test.go

@@ -1,12 +1,17 @@
 package hostCoretest
 
 import (
+	"context"
 	"testing"
+	"time"
 
 	"github.com/multiversx/mx-chain-vm-go/executor"
 	contextmock "github.com/multiversx/mx-chain-vm-go/mock/context"
 	test "github.com/multiversx/mx-chain-vm-go/testcommon"
 	"github.com/multiversx/mx-chain-vm-go/vmhost"
+	"github.com/multiversx/mx-chain-vm-go/wasmer"
+	"github.com/multiversx/mx-chain-vm-go/wasmer2"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBadContract_NoPanic_Memoryfault(t *testing.T) {
@@ -251,3 +256,42 @@ func TestBadContract_NoPanic_NonExistingFunction(t *testing.T) {
 				HasRuntimeErrorAndInfo(executor.ErrInvalidFunction.Error(), "thisDoesNotExist")
 		})
 }
+
+func TestBadContractExtra_LongIntLoop_Wasmer1(t *testing.T) {
+	testBadContractExtraLongIntLoop(t, wasmer.ExecutorFactory())
+}
+
+func TestBadContractExtra_LongIntLoop_Wasmer2(t *testing.T) {
+	testBadContractExtraLongIntLoop(t, wasmer2.ExecutorFactory())
+}
+
+func testBadContractExtraLongIntLoop(t *testing.T, executorFactory executor.ExecutorAbstractFactory) {
+	testCase := test.BuildInstanceCallTest(t).WithContracts(
+		test.CreateInstanceContract(test.ParentAddress).
+			WithCode(test.GetTestSCCode("bad-extra", "../../"))).
+		WithInput(test.CreateTestContractCallInputBuilder().
+			WithRecipientAddr(test.ParentAddress).
+			WithGasProvided(test.GasProvided).
+			WithFunction("bigLoop").
+			Build()).
+		WithExecutorFactory(executorFactory).
+		WithWasmerSIGSEGVPassthrough(false)
+
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	done := make(chan struct{})
+	go func() {
+		testCase.AndAssertResults(func(_ vmhost.VMHost, _ *contextmock.BlockchainHookStub, verify *test.VMOutputVerifier) {
+			verify.OutOfGas()
+		})
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		return
+	case <-ctx.Done():
+		require.FailNow(t, "test timed out")
+	}
+}

vmhost/hosttest/execution_test.go

@@ -211,7 +211,7 @@ func TestExecution_DeployWASM_Popcnt(t *testing.T) {
 func TestExecution_DeployWASM_AtMaximumLocals(t *testing.T) {
 	test.BuildInstanceCreatorTest(t).
 		WithInput(test.CreateTestContractCreateInputBuilder().
-			WithGasProvided(1000).
+			WithGasProvided(100000).
 			WithCallValue(88).
 			WithContractCode(makeBytecodeWithLocals(WASMLocalsLimit)).
 			Build()).
@@ -3692,8 +3692,9 @@ func TestExecution_Mocked_OnSameFollowedByOnDest(t *testing.T) {
 // number of i64 locals it instantiates
 func makeBytecodeWithLocals(numLocals uint64) []byte {
 	originalCode := test.GetTestSCCode("answer-locals", "../../")
-	firstSlice := originalCode[:0x5B]
-	secondSlice := originalCode[0x5C:]
+
+	firstSlice := originalCode[:0x66]
+	secondSlice := originalCode[0x67:]
 
 	encodedNumLocals := vmhost.U64ToLEB128(numLocals)
 	extraBytes := len(encodedNumLocals) - 1
@@ -3703,8 +3704,8 @@ func makeBytecodeWithLocals(numLocals uint64) []byte {
 	result = append(result, encodedNumLocals...)
 	result = append(result, secondSlice...)
 
-	result[0x57] = byte(int(result[0x57]) + extraBytes)
-	result[0x59] = byte(int(result[0x59]) + extraBytes)
+	result[0x5F] = byte(int(result[0x5F]) + extraBytes)
+	result[0x64] = byte(int(result[0x64]) + extraBytes)
 
 	return result
 }