cmd: qualify the LLVM backend on linux/amd64

src/cmd/compile/internal/ssa/ssa2llvm.go

@@ -603,7 +603,12 @@ func (lfc *LLVMFuncContext) staticCall(v *Value) llvm.Value {
 	cc := llvmCallConv(aux.ABI().Which())
 	fn := getOrInsertLLVMFunction(aux.Fn.Name, sig, cc)
 	attachGoObjSymbolRef(fn, aux.Fn)
-	rawWriteBarrier := aux.Fn == ir.Syms.WBZero || aux.Fn == ir.Syms.WBMove
+	// AMD64 rewrites some Move and Eq operations to static runtime calls before
+	// LLVM emission. Keep the same leaf contract as the dedicated LLVM lowering
+	// paths so RewriteStatepointsForGC does not turn these raw helpers into
+	// statepoints.
+	llvmGCLeaf := aux.Fn == ir.Syms.WBZero || aux.Fn == ir.Syms.WBMove ||
+		aux.Fn == ir.Syms.Memmove || aux.Fn == ir.Syms.Memequal
 	args := make([]llvm.Value, 0, aux.NArgs())
 	for i := int64(0); i < aux.NArgs(); i++ {
 		arg := lfc.GenLV(v.Args[i])
@@ -618,7 +623,7 @@ func (lfc *LLVMFuncContext) staticCall(v *Value) llvm.Value {
 	}
 	call := lfc.b.CreateCall(sig.Type, fn, args, name)
 	call.SetInstructionCallConv(cc)
-	if rawWriteBarrier {
+	if llvmGCLeaf {
 		markLLVMGCLeaf(fn, call)
 	}
 	return call

src/cmd/dist/build.go

@@ -1924,6 +1924,7 @@ func isGoallcLLVMSystemLibrary(library string) bool {
 	allowed := map[string]bool{
 		"-lm":       true,
 		"-lz":       true,
+		"-lzstd":    true,
 		"-lxml2":    true,
 		"-ldl":      true,
 		"-lpthread": true,

src/cmd/go.mod

@@ -3,7 +3,7 @@ module cmd
 go 1.27
 
 require (
-	github.com/goallc/go-llvm v0.0.0-20260802014221-e0a85f0a18bc
+	github.com/goallc/go-llvm v0.0.0-20260802062312-1f9c9bc944a6
 	github.com/google/pprof v0.0.0-20260507013755-92041b743c96
 	golang.org/x/arch v0.27.1-0.20260521044007-9c1a596a2c97
 	golang.org/x/build v0.0.0-20260522210304-d55d0041b921

src/cmd/go.sum

@@ -1,5 +1,5 @@
-github.com/goallc/go-llvm v0.0.0-20260802014221-e0a85f0a18bc h1:d8GeynggX+JI+ntwrs/9PyA3QYqYtNar6XqPSDEdoAE=
-github.com/goallc/go-llvm v0.0.0-20260802014221-e0a85f0a18bc/go.mod h1:s70tU8u5zDo1LwIPqBxh6Qgol/tNt1kmn9caPfsTz8A=
+github.com/goallc/go-llvm v0.0.0-20260802062312-1f9c9bc944a6 h1:5Ipo1Z/H/Aet8t3N1+a0o+vh7NVRfXpWeCYngaKHOOM=
+github.com/goallc/go-llvm v0.0.0-20260802062312-1f9c9bc944a6/go.mod h1:s70tU8u5zDo1LwIPqBxh6Qgol/tNt1kmn9caPfsTz8A=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/pprof v0.0.0-20260507013755-92041b743c96 h1:YDDnaZ9afWajDboPMt9Vikqca/yWAX7KAxVzb4lJU1M=

src/cmd/internal/testdir/llvm_abi_test.go

@@ -84,14 +84,18 @@ type llvmABICase struct {
 
 func runLLVMABIDifferentialTest(t *testing.T, gorootTestDir string) {
 	t.Helper()
-	if runtime.GOOS == "linux" && runtime.GOARCH == "amd64" {
+	switch runtime.GOOS + "/" + runtime.GOARCH {
+	case "darwin/arm64":
+		runLLVMAArch64ABIDifferentialTest(t, gorootTestDir)
+	case "linux/amd64":
 		runLLVMAMD64ArgsPointerMapDifferentialTest(t, gorootTestDir)
-		return
-	}
-	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
-		t.Skip("exact ABI differential expectations are currently qualified on darwin/arm64")
+	default:
+		t.Skip("exact ABI differential expectations are currently qualified on darwin/arm64 and linux/amd64")
 	}
+}
 
+func runLLVMAArch64ABIDifferentialTest(t *testing.T, gorootTestDir string) {
+	t.Helper()
 	dir := t.TempDir()
 	source := filepath.Join(gorootTestDir, "abi", "llvm_args_results.go")
 	nativeObject := filepath.Join(dir, "native.o")
@@ -424,7 +428,7 @@ func runLLVMAMD64ArgsPointerMapDifferentialTest(t *testing.T, gorootTestDir stri
 	machinePatterns := map[string][]string{
 		"p.initializedPointerResult": {
 			`STATEPOINT 5147424658422983495,[^\n]*\$rsp, 72,`,
-			`STATEPOINT -[0-9]+,[^\n]*\$rsp, 8,`,
+			`STATEPOINT -[0-9]+,[^\n]*\$rsp, 0,`,
 		},
 		"p.partiallyInitializedAggregateResult": {
 			`STATEPOINT 5147424658422983495,[^\n]*\$rsp, 80,[^\n]*\$rsp, 88,`,
@@ -483,11 +487,11 @@ func runLLVMAMD64ArgsPointerMapDifferentialTest(t *testing.T, gorootTestDir stri
 	cases := []amd64Case{
 		{
 			name: "initializedPointerResult", args: 72, entryBits: []int{8},
-			goallcLocals: 24, goallcArgs: [][]int{{8}, nil},
-			goallcMaps:   [][]int{nil, {2}},
+			goallcLocals: 16, goallcArgs: [][]int{{8}, nil},
+			goallcMaps:   [][]int{nil, {1}},
 			nativePCData: []int32{-1, 0, -1}, goallcPCData: []int32{-1, 1, 0},
 			nativeQueries: []int32{0, -1}, goallcQueries: []int32{1, 0},
-			nativePCSP: []int32{0, 8, 0}, goallcPCSP: []int32{0, 8, 24, 8, 0},
+			nativePCSP: []int32{0, 8, 0}, goallcPCSP: []int32{0, 8, 16, 8, 0},
 		},
 		{
 			name: "partiallyInitializedAggregateResult", args: 88,

src/cmd/internal/testdir/llvm_alloca_test.go

@@ -14,10 +14,30 @@ import (
 	"testing"
 )
 
+type llvmAllocaArchitectureChecks struct {
+	machineAllocaPattern string
+	betweenCallsPattern  string
+	restoredStorePattern string
+}
+
+var llvmAllocaChecks = map[string]llvmAllocaArchitectureChecks{
+	"darwin/arm64": {
+		machineAllocaPattern: `(?s)stack:.*?size:\s+40,\s+alignment:\s+8`,
+		betweenCallsPattern:  `(?s)\bbl\s+p\.mutateLocal\n(.*?)\bbl\s+p\.safepoint`,
+		restoredStorePattern: `(?m)^\s*(?:str|stp)\b`,
+	},
+	"linux/amd64": {
+		machineAllocaPattern: `(?s)stack:.*?size:\s+40,\s+alignment:\s+8`,
+		betweenCallsPattern:  `(?s)\bcallq\s+p\.mutateLocal\n(.*?)\bcallq\s+p\.safepoint`,
+		restoredStorePattern: `(?m)^\s*mov[a-z]*\s+[^,\n]+,\s*-[0-9]+\(%rbp\)`,
+	},
+}
+
 func runLLVMAllocaStatepointTest(t *testing.T, gorootTestDir string) {
 	t.Helper()
-	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
-		t.Skip("exact alloca statepoint frame and stack-map expectations are qualified on darwin/arm64")
+	checks, ok := llvmAllocaChecks[runtime.GOOS+"/"+runtime.GOARCH]
+	if !ok {
+		t.Skip("exact alloca statepoint frame and stack-map expectations are qualified on darwin/arm64 and linux/amd64")
 	}
 
 	dir := t.TempDir()
@@ -98,7 +118,7 @@ func runLLVMAllocaStatepointTest(t *testing.T, gorootTestDir string) {
 		"-load-pass-plugin="+plugin, "-stop-after=finalize-isel",
 		"-o", "-", goallcIR)
 	machineFunction := llvmABIMachineFunction(t, machineIR, "p.localAcrossSafepoints")
-	if !regexp.MustCompile(`(?s)stack:.*?size:\s+40,\s+alignment:\s+16`).Match(machineFunction) {
+	if !regexp.MustCompile(checks.machineAllocaPattern).Match(machineFunction) {
 		t.Fatalf("MIR has no 40-byte pointer alloca\n%s", machineFunction)
 	}
 	ordinaryStatepoints := regexp.MustCompile(`(?m)^.*STATEPOINT.*%stack\.[0-9]+.*$`).
@@ -132,12 +152,11 @@ func runLLVMAllocaStatepointTest(t *testing.T, gorootTestDir string) {
 	goallcAssembly := runLLVMABICommand(t, nil, llc,
 		"-load-pass-plugin="+plugin, "-verify-machineinstrs",
 		"-filetype=asm", "-o", "-", goallcIR)
-	betweenCalls := regexp.MustCompile(`(?s)\bbl\s+p\.mutateLocal\n(.*?)\bbl\s+p\.safepoint`).
-		FindSubmatch(goallcAssembly)
+	betweenCalls := regexp.MustCompile(checks.betweenCallsPattern).FindSubmatch(goallcAssembly)
 	if len(betweenCalls) != 2 {
 		t.Fatalf("GoALLC assembly has no adjacent mutateLocal/safepoint calls\n%s", goallcAssembly)
 	}
-	if regexp.MustCompile(`(?m)^\s*(?:str|stp)\b`).Match(betweenCalls[1]) {
+	if regexp.MustCompile(checks.restoredStorePattern).Match(betweenCalls[1]) {
 		t.Fatalf("GoALLC restored an alloca field after mutateLocal:\n%s", betweenCalls[1])
 	}
 

src/cmd/internal/testdir/llvm_test.go

@@ -273,7 +273,7 @@ func runLLVMCodegenTest(t *testing.T, gorootTestDir, name string) {
 		t.Fatalf("LLVM verifier failed: %v\n%s", err, out)
 	}
 	fileCheck := llvmToolPath(t, "FileCheck", "GOALLC_FILECHECK")
-	cmd = exec.Command(fileCheck, "--check-prefix=LLVM", source)
+	cmd = exec.Command(fileCheck, "--check-prefixes="+llvmFileCheckPrefixes("LLVM", src), source)
 	cmd.Stdin = bytes.NewReader(irBytes)
 	cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=")
 	if out, err := cmd.CombinedOutput(); err != nil {
@@ -292,14 +292,31 @@ func runLLVMCodegenTest(t *testing.T, gorootTestDir, name string) {
 	if err != nil {
 		t.Fatalf("LLVM optimization failed: %v\n%s", err, stderr.Bytes())
 	}
-	cmd = exec.Command(fileCheck, "--check-prefix=LLVM-OPT", source)
+	cmd = exec.Command(fileCheck, "--check-prefixes="+llvmFileCheckPrefixes("LLVM-OPT", src), source)
 	cmd.Stdin = bytes.NewReader(optimizedIR)
 	cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Fatalf("optimized LLVM FileCheck failed: %v\n%s", err, out)
 	}
 }
 
+func llvmFileCheckPrefixes(base string, source []byte) string {
+	prefixes := []string{base}
+	var architecturePrefix string
+	switch runtime.GOARCH {
+	case "amd64":
+		architecturePrefix = base + "-AMD64"
+	case "arm64":
+		architecturePrefix = base + "-ARM64"
+	}
+	if architecturePrefix != "" &&
+		(bytes.Contains(source, []byte(architecturePrefix+":")) ||
+			bytes.Contains(source, []byte(architecturePrefix+"-"))) {
+		prefixes = append(prefixes, architecturePrefix)
+	}
+	return strings.Join(prefixes, ",")
+}
+
 func runLLVMWriteBarrierIRTests(t *testing.T) {
 	tests := []struct {
 		name   string

src/cmd/internal/testdir/llvm_writebarrier_test.go

@@ -6,24 +6,36 @@ package testdir_test
 
 import (
 	"bytes"
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
 	"testing"
 )
 
+type llvmWriteBarrierArchitectureChecks struct {
+	moveType     string
+	moveElements int
+}
+
+var llvmWriteBarrierChecks = map[string]llvmWriteBarrierArchitectureChecks{
+	"darwin/arm64": {moveType: "Move8", moveElements: 8},
+	"linux/amd64":  {moveType: "Move2", moveElements: 2},
+}
+
 func runLLVMWriteBarrierHelperTest(t *testing.T) {
 	t.Helper()
-	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
-		t.Skip("write-barrier helper IR and RS4GC expectations are qualified on darwin/arm64")
+	checks, ok := llvmWriteBarrierChecks[runtime.GOOS+"/"+runtime.GOARCH]
+	if !ok {
+		t.Skip("write-barrier helper IR and RS4GC expectations are qualified on darwin/arm64 and linux/amd64")
 	}
 
 	dir := t.TempDir()
 	source := filepath.Join(dir, "writebarrier.go")
-	const program = `package p
+	program := fmt.Sprintf(`package p
 
 type Big [32]*int
-type Move8 [8]*int
+type %[1]s [%[2]d]*int
 
 func ordinary(*int)
 
@@ -37,10 +49,10 @@ func heapZero(dst *Big, live *int) {
 }
 
 //go:noinline
-func heapMove(dst, src *Move8) {
+func heapMove(dst, src *%[1]s) {
 	*dst = *src
 }
-`
+`, checks.moveType, checks.moveElements)
 	if err := os.WriteFile(source, []byte(program), 0o666); err != nil {
 		t.Fatal(err)
 	}
@@ -70,7 +82,7 @@ func heapMove(dst, src *Move8) {
 			name: "wbMove",
 			body: llvmAllocaIRFunction(t, ir, "p.heapMove"),
 			want: [][]byte{
-				[]byte("call goabiinternal void @runtime.wbMove(ptr @\"type:p.Move8\", ptr %dst, ptr %src)"),
+				[]byte(fmt.Sprintf("call goabiinternal void @runtime.wbMove(ptr @\"type:p.%s\", ptr %%dst, ptr %%src)", checks.moveType)),
 			},
 		},
 	} {

src/cmd/llvmplugin/CMakeLists.txt

@@ -168,7 +168,7 @@ if(BUILD_TESTING)
   foreach(GOALLC_CALLIND_TARGET IN ITEMS X86 AArch64)
     if(GOALLC_CALLIND_TARGET STREQUAL "X86")
       set(GOALLC_CALLIND_TRIPLE "x86_64-unknown-linux-goobj")
-      set(GOALLC_CALLIND_OFFSET 20)
+      set(GOALLC_CALLIND_OFFSET 17)
       set(GOALLC_DIRECT_CALL_RELOC 7)
     else()
       set(GOALLC_CALLIND_TRIPLE "aarch64-unknown-linux-goobj")

src/cmd/llvmplugin/testdata/alloca-pointer-vector-unsupported.ll

@@ -4,7 +4,7 @@ declare goabiinternal void @safepoint()
 
 define goabiinternal void @pointer_vector_alloca() "go-stack-growth-statepoint" gc "goallc" {
 entry:
-  %slot = alloca <2 x ptr>, align 16
+  %slot = alloca <2 x ptr>, align 8
   call goabiinternal void @safepoint()
   ret void
 }

src/cmd/vendor/modules.txt

@@ -1,4 +1,4 @@
-# github.com/goallc/go-llvm v0.0.0-20260802014221-e0a85f0a18bc
+# github.com/goallc/go-llvm v0.0.0-20260802062312-1f9c9bc944a6
 ## explicit; go 1.24
 github.com/goallc/go-llvm
 # github.com/google/pprof v0.0.0-20260507013755-92041b743c96

test/codegen/interface_assertion.go

@@ -21,7 +21,7 @@ func (v llvmAssertionValue) Value(delta int) int {
 // LLVM-LABEL: define goabiinternal { { ptr, ptr }, i8 } @codegen.assertLLVMInterface(
 // LLVM: load atomic ptr, ptr @codegen..typeAssert.0 seq_cst
 // LLVM: call goabiinternal ptr @runtime.typeAssert(ptr @codegen..typeAssert.0, ptr
-// LLVM-DAG: declare goabiinternal ptr @runtime.typeAssert(ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal ptr @runtime.typeAssert(ptr, ptr)
 // LLVM-LABEL: define goabiinternal { i64, i8 } @codegen.assertLLVMConcrete(
 // LLVM: extractvalue { ptr, ptr }
 // LLVM: icmp eq ptr
@@ -39,8 +39,8 @@ func assertLLVMInterface(v any) (llvmAssertionInterface, bool) {
 
 // LLVM-DAG: call goabiinternal void @runtime.panicdottypeE(
 // LLVM-DAG: call goabiinternal void @runtime.panicnildottype(
-// LLVM-DAG: declare goabiinternal void @runtime.panicdottypeE(ptr, ptr, ptr)
-// LLVM-DAG: declare goabiinternal void @runtime.panicnildottype(ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal void @runtime.panicdottypeE(ptr, ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal void @runtime.panicnildottype(ptr)
 func mustLLVMConcrete(v any) llvmAssertionValue {
 	return v.(llvmAssertionValue)
 }

test/codegen/interface_conversion.go

@@ -11,7 +11,7 @@ package codegen
 // LLVM: load atomic ptr, ptr @codegen..typeAssert.0 seq_cst
 // LLVM: ptrtoint ptr
 // LLVM: call goabiinternal ptr @runtime.typeAssert(ptr @codegen..typeAssert.0, ptr
-// LLVM-DAG: declare goabiinternal ptr @runtime.typeAssert(ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal ptr @runtime.typeAssert(ptr, ptr)
 // LLVM: !goobj.gotype = !{
 // LLVM-DAG: !{ptr @codegen..typeAssert.0, ptr @
 

test/codegen/interface_equality.go

@@ -18,14 +18,14 @@ func (v llvmEqualityValue) Value() int {
 
 // LLVM-DAG: define goabiinternal i8 @codegen.equalLLVMEmpty(
 // LLVM-DAG: call goabiinternal i8 @runtime.efaceeq(ptr
-// LLVM-DAG: declare goabiinternal i8 @runtime.efaceeq(ptr, ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal i8 @runtime.efaceeq(ptr, ptr, ptr)
 func equalLLVMEmpty(a, b any) bool {
 	return a == b
 }
 
 // LLVM-DAG: define goabiinternal i8 @codegen.equalLLVMNonEmpty(
 // LLVM-DAG: call goabiinternal i8 @runtime.ifaceeq(ptr
-// LLVM-DAG: declare goabiinternal i8 @runtime.ifaceeq(ptr, ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal i8 @runtime.ifaceeq(ptr, ptr, ptr)
 func equalLLVMNonEmpty(a, b llvmEqualityInterface) bool {
 	return a == b
 }

test/codegen/interface_switch.go

@@ -29,7 +29,7 @@ func (v llvmDoubleSwitchValue) Double() int {
 // LLVM-DAG: @codegen..interfaceSwitch.0 = internal global <{ ptr, [8 x i8], ptr, ptr }>
 // LLVM-DAG: load atomic ptr, ptr @codegen..interfaceSwitch.0 seq_cst
 // LLVM-DAG: call goabiinternal { i64, ptr } @runtime.interfaceSwitch(ptr @codegen..interfaceSwitch.0, ptr
-// LLVM-DAG: declare goabiinternal { i64, ptr } @runtime.interfaceSwitch(ptr, ptr)
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal { i64, ptr } @runtime.interfaceSwitch(ptr, ptr)
 // LLVM-DAG: icmp eq ptr
 // LLVM-DAG: @"type:codegen.llvmSwitchValue"
 // LLVM-DAG: @"type:string"

test/codegen/llvm_memops.go

@@ -75,27 +75,29 @@ func llvmMovePointerToStack(src *llvmPointerStackZero) *int {
 }
 
 // LLVM-DAG: define goabiinternal void @codegen.llvmMoveOverlapSized(
-// LLVM-DAG: call void @llvm.memmove.p0.p0.i64(ptr align 1 %dst, ptr align 1 %src, i64 32, i1 false)
+// LLVM-ARM64-DAG: call void @llvm.memmove.p0.p0.i64(ptr align 1 %dst, ptr align 1 %src, i64 32, i1 false)
+// LLVM-AMD64-DAG: call goabiinternal void @runtime.memmove(ptr %dst, ptr %src, i64 32) #{{[0-9]+}}
 func llvmMoveOverlapSized(dst, src *[32]byte) {
 	*dst = *src
 }
 
 // LLVM-DAG: define goabiinternal void @codegen.llvmMoveAligned(
-// LLVM-DAG: call void @llvm.memmove.p0.p0.i64(ptr align 8 %dst, ptr align 8 %src, i64 24, i1 false)
+// LLVM-ARM64-DAG: call void @llvm.memmove.p0.p0.i64(ptr align 8 %dst, ptr align 8 %src, i64 24, i1 false)
+// LLVM-AMD64-DAG: call goabiinternal void @runtime.memmove(ptr %dst, ptr %src, i64 24) #{{[0-9]+}}
 func llvmMoveAligned(dst, src *[3]uint64) {
 	*dst = *src
 }
 
 // LLVM-DAG: define goabiinternal void @codegen.llvmMoveLarge(
 // LLVM-DAG: call goabiinternal void @runtime.memmove(ptr %dst, ptr {{%.*}}, i64 128) #{{[0-9]+}}
-// LLVM-DAG: declare goabiinternal void @runtime.memmove(ptr, ptr, i64) #{{[0-9]+}}
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal void @runtime.memmove(ptr, ptr, i64) #{{[0-9]+}}
 func llvmMoveLarge(dst *[128]byte, src [128]byte) {
 	*dst = src
 }
 
 // LLVM-DAG: define goabiinternal i8 @codegen.llvmMemEq(
 // LLVM-DAG: call goabiinternal i8 @runtime.memequal(ptr {{%.*}}, ptr {{%.*}}, i64 {{%.*}}) #{{[0-9]+}}
-// LLVM-DAG: declare goabiinternal i8 @runtime.memequal(ptr, ptr, i64) #{{[0-9]+}}
+// LLVM-DAG: declare !goobj.builtin !{{[0-9]+}} goabiinternal i8 @runtime.memequal(ptr, ptr, i64) #{{[0-9]+}}
 func llvmMemEq(a, b string) bool {
 	return a == b
 }

test/codegen/llvm_newproc.go

@@ -10,7 +10,7 @@ package codegen
 // LLVM: call goabiinternal void @runtime.newproc(ptr
 // LLVM-NOT: call goabiinternal void @runtime.newproc(i64
 // LLVM: ret void
-// LLVM: declare goabiinternal void @runtime.newproc(ptr)
+// LLVM: declare !goobj.builtin !{{[0-9]+}} goabiinternal void @runtime.newproc(ptr)
 var llvmNewprocSink int
 
 func llvmNewproc(value int) {