test: fix tests on arm64

* remove skip-code of some arm64 tests, which implemented.
* fix errors in testsuits for arm64

.travis.yml

@@ -18,6 +18,9 @@ go:
 matrix:
   allow_failures:
     - go: tip
+  exclude:
+    - os: osx
+      arch: arm64
 
 before_install:
   - export GOFLAGS=-mod=vendor

pkg/proc/proc_test.go

@@ -543,9 +543,6 @@ func TestNextConcurrent(t *testing.T) {
 	if runtime.GOOS == "freebsd" {
 		t.Skip("test is not valid on FreeBSD")
 	}
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	testcases := []nextTest{
 		{8, 9},
 		{9, 10},
@@ -584,9 +581,6 @@ func TestNextConcurrentVariant2(t *testing.T) {
 	if runtime.GOOS == "freebsd" {
 		t.Skip("test is not valid on FreeBSD")
 	}
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	// Just like TestNextConcurrent but instead of removing the initial breakpoint we check that when it happens is for other goroutines
 	testcases := []nextTest{
 		{8, 9},
@@ -830,7 +824,7 @@ func (l1 *loc) match(l2 proc.Stackframe) bool {
 
 func TestStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	stacks := [][]loc{
 		{{4, "main.stacktraceme"}, {8, "main.func1"}, {16, "main.main"}},
@@ -868,7 +862,7 @@ func TestStacktrace(t *testing.T) {
 
 func TestStacktrace2(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	withTestProcess("retstack", t, func(p proc.Process, fixture protest.Fixture) {
 		assertNoError(proc.Continue(p), t, "Continue()")
@@ -919,7 +913,7 @@ func stackMatch(stack []loc, locations []proc.Stackframe, skipRuntime bool) bool
 
 func TestStacktraceGoroutine(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	mainStack := []loc{{14, "main.stacktraceme"}, {29, "main.main"}}
 	if goversion.VersionAfterOrEqual(runtime.Version(), 1, 11) {
@@ -1050,9 +1044,6 @@ func TestGetG(t *testing.T) {
 }
 
 func TestContinueMulti(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	protest.AllowRecording(t)
 	withTestProcess("integrationprog", t, func(p proc.Process, fixture protest.Fixture) {
 		bp1 := setFunctionBreakpoint(p, t, "main.main")
@@ -1247,7 +1238,7 @@ func TestVariableEvaluation(t *testing.T) {
 
 func TestFrameEvaluation(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	protest.AllowRecording(t)
 	withTestProcess("goroutinestackprog", t, func(p proc.Process, fixture protest.Fixture) {
@@ -1403,9 +1394,6 @@ func TestBreakpointCounts(t *testing.T) {
 	if runtime.GOOS == "freebsd" {
 		t.Skip("test is not valid on FreeBSD")
 	}
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	protest.AllowRecording(t)
 	withTestProcess("bpcountstest", t, func(p proc.Process, fixture protest.Fixture) {
 		bp := setFileBreakpoint(p, t, fixture.Source, 12)
@@ -1733,7 +1721,7 @@ func TestIssue384(t *testing.T) {
 
 func TestIssue332_Part1(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// Next shouldn't step inside a function call
 	protest.AllowRecording(t)
@@ -1757,7 +1745,7 @@ func TestIssue332_Part1(t *testing.T) {
 
 func TestIssue332_Part2(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// Step should skip a function's prologue
 	// In some parts of the prologue, for some functions, the FDE data is incorrect
@@ -1916,6 +1904,9 @@ func TestCmdLineArgs(t *testing.T) {
 }
 
 func TestIssue462(t *testing.T) {
+	if runtime.GOARCH == "arm64" {
+		t.Skip("arm64 do not support Stacktrace for now")
+	}
 	// Stacktrace of Goroutine 0 fails with an error
 	if runtime.GOOS == "windows" {
 		return
@@ -1946,7 +1937,7 @@ func TestNextParked(t *testing.T) {
 		t.Skip("test is not valid on FreeBSD")
 	}
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	protest.AllowRecording(t)
 	withTestProcess("parallel_next", t, func(p proc.Process, fixture protest.Fixture) {
@@ -1999,7 +1990,7 @@ func TestNextParked(t *testing.T) {
 
 func TestStepParked(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	if runtime.GOOS == "freebsd" {
 		t.Skip("test is not valid on FreeBSD")
@@ -2325,7 +2316,7 @@ func TestStepConcurrentDirect(t *testing.T) {
 		t.Skip("test is not valid on FreeBSD")
 	}
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	protest.AllowRecording(t)
 	withTestProcess("teststepconcurrent", t, func(p proc.Process, fixture protest.Fixture) {
@@ -2390,9 +2381,6 @@ func TestStepConcurrentDirect(t *testing.T) {
 }
 
 func TestStepConcurrentPtr(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	if runtime.GOOS == "freebsd" {
 		t.Skip("test is not valid on FreeBSD")
 	}
@@ -2494,11 +2482,14 @@ func TestStepOutDeferReturnAndDirectCall(t *testing.T) {
 		{contStepout, 28}})
 }
 
-const maxInstructionLength uint64 = 15
+var maxInstructionLength uint64
 
 func TestStepOnCallPtrInstr(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
+	switch runtime.GOARCH {
-		t.Skip("test is not valid on ARM64")
+	case "amd64":
+		maxInstructionLength = 15
+	case "arm64":
+		maxInstructionLength = 4
 	}
 	protest.AllowRecording(t)
 	withTestProcess("teststepprog", t, func(p proc.Process, fixture protest.Fixture) {
@@ -2709,7 +2700,7 @@ func getg(goid int, gs []*proc.G) *proc.G {
 
 func TestStacktraceWithBarriers(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// Go's Garbage Collector will insert stack barriers into stacks.
 	// This stack barrier is inserted by overwriting the return address for the
@@ -3273,8 +3264,8 @@ func frameInFile(frame proc.Stackframe, file string) bool {
 }
 
 func TestCgoStacktrace(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
+	if runtime.GOARCH != "amd64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("amd64 only")
 	}
 	if runtime.GOOS == "windows" {
 		ver, _ := goversion.Parse(runtime.Version())
@@ -3382,7 +3373,7 @@ func TestCgoStacktrace(t *testing.T) {
 
 func TestCgoSources(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Cgo-debug for now")
 	}
 	if runtime.GOOS == "windows" {
 		ver, _ := goversion.Parse(runtime.Version())
@@ -3410,7 +3401,7 @@ func TestCgoSources(t *testing.T) {
 
 func TestSystemstackStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// check that we can follow a stack switch initiated by runtime.systemstack()
 	withTestProcess("panic", t, func(p proc.Process, fixture protest.Fixture) {
@@ -3431,7 +3422,7 @@ func TestSystemstackStacktrace(t *testing.T) {
 
 func TestSystemstackOnRuntimeNewstack(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// The bug being tested here manifests as follows:
 	// - set a breakpoint somewhere or interrupt the program with Ctrl-C
@@ -3467,7 +3458,7 @@ func TestSystemstackOnRuntimeNewstack(t *testing.T) {
 
 func TestIssue1034(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace and Cgo-debug for now")
 	}
 	// The external linker on macOS produces an abbrev for DW_TAG_subprogram
 	// without the "has children" flag, we should support this.
@@ -3487,7 +3478,7 @@ func TestIssue1034(t *testing.T) {
 
 func TestIssue1008(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace and Cgo-debug for now")
 	}
 	// The external linker on macOS inserts "end of sequence" extended opcodes
 	// in debug_line. which we should support correctly.
@@ -3666,7 +3657,7 @@ func TestAllPCsForFileLines(t *testing.T) {
 
 func TestInlinedStacktraceAndVariables(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	if ver, _ := goversion.Parse(runtime.Version()); ver.Major >= 0 && !ver.AfterOrEqual(goversion.GoVersion{1, 10, -1, 0, 0, ""}) {
 		// Versions of go before 1.10 do not have DWARF information for inlined calls
@@ -3959,9 +3950,6 @@ func TestMapLoadConfigWithReslice(t *testing.T) {
 }
 
 func TestStepOutReturn(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	ver, _ := goversion.Parse(runtime.Version())
 	if ver.Major >= 0 && !ver.AfterOrEqual(goversion.GoVersion{1, 10, -1, 0, 0, ""}) {
 		t.Skip("return variables aren't marked on 1.9 or earlier")
@@ -4102,8 +4090,8 @@ func TestReadDefer(t *testing.T) {
 }
 
 func TestNextUnknownInstr(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
+	if runtime.GOARCH != "amd64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("amd64 only")
 	}
 	if !goversion.VersionAfterOrEqual(runtime.Version(), 1, 10) {
 		t.Skip("versions of Go before 1.10 can't assemble the instruction VPUNPCKLWD")
@@ -4117,7 +4105,7 @@ func TestNextUnknownInstr(t *testing.T) {
 
 func TestReadDeferArgs(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	var tests = []struct {
 		frame, deferCall int
@@ -4163,7 +4151,7 @@ func TestReadDeferArgs(t *testing.T) {
 
 func TestIssue1374(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	// Continue did not work when stopped at a breakpoint immediately after calling CallFunction.
 	protest.MustSupportFunctionCalls(t, testBackend)
@@ -4385,7 +4373,7 @@ func TestCallConcurrent(t *testing.T) {
 		t.Skip("test is not valid on FreeBSD")
 	}
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 	withTestProcess("teststepconcurrent", t, func(p proc.Process, fixture protest.Fixture) {
@@ -4469,7 +4457,7 @@ func TestIssue1615(t *testing.T) {
 
 func TestCgoStacktrace2(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace and Cgo-debug for now")
 	}
 	if runtime.GOOS == "windows" {
 		t.Skip("fixture crashes go runtime on windows")
@@ -4486,8 +4474,8 @@ func TestCgoStacktrace2(t *testing.T) {
 }
 
 func TestIssue1656(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
+	if runtime.GOARCH != "amd64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("amd64 only")
 	}
 	withTestProcess("issue1656/", t, func(p proc.Process, fixture protest.Fixture) {
 		setFileBreakpoint(p, t, filepath.ToSlash(filepath.Join(fixture.BuildDir, "main.s")), 5)

pkg/proc/variable_test.go

@@ -11,7 +11,7 @@ import (
 
 func TestGoroutineCreationLocation(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support GetStackInfo for now")
 	}
 	protest.AllowRecording(t)
 	withTestProcess("goroutinestackprog", t, func(p proc.Process, fixture protest.Fixture) {

pkg/terminal/command_test.go

@@ -283,7 +283,7 @@ func TestIssue411(t *testing.T) {
 
 func TestScopePrefix(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	const goroutinesLinePrefix = "  Goroutine "
 	const goroutinesCurLinePrefix = "* Goroutine "
@@ -678,9 +678,6 @@ func TestCheckpoints(t *testing.T) {
 }
 
 func TestNextWithCount(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	test.AllowRecording(t)
 	withTestTerminal("nextcond", t, func(term *FakeTerminal) {
 		term.MustExec("break main.main")
@@ -850,7 +847,7 @@ func TestIssue1090(t *testing.T) {
 
 func TestPrintContextParkedGoroutine(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	withTestTerminal("goroutinestackprog", t, func(term *FakeTerminal) {
 		term.MustExec("break stacktraceme")
@@ -887,9 +884,6 @@ func TestPrintContextParkedGoroutine(t *testing.T) {
 }
 
 func TestStepOutReturn(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	ver, _ := goversion.Parse(runtime.Version())
 	if ver.Major >= 0 && !ver.AfterOrEqual(goversion.GoVersion{1, 10, -1, 0, 0, ""}) {
 		t.Skip("return variables aren't marked on 1.9 or earlier")
@@ -929,7 +923,7 @@ func TestOptimizationCheck(t *testing.T) {
 
 func TestTruncateStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	withTestTerminal("stacktraceprog", t, func(term *FakeTerminal) {
 		term.MustExec("break main.stacktraceme")
@@ -949,7 +943,7 @@ func TestTruncateStacktrace(t *testing.T) {
 
 func TestIssue1493(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FpRegs for now")
 	}
 	// The 'regs' command without the '-a' option should only return
 	// general purpose registers.
@@ -972,7 +966,7 @@ func findStarFile(name string) string {
 
 func TestIssue1598(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	test.MustSupportFunctionCalls(t, testBackend)
 	withTestTerminal("issue1598", t, func(term *FakeTerminal) {

scripts/make.go

@@ -79,7 +79,7 @@ Use the flags -s, -r and -b to specify which tests to run. Specifying nothing is
 `,
 		Run: testCmd,
 	}
-	test.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", true, "Verbose tests")
+	test.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "Verbose tests")
 	test.PersistentFlags().StringVarP(&TestSet, "test-set", "s", "", `Select the set of tests to run, one of either:
 	all		tests all packages
 	basic		tests proc, integration and terminal

service/test/integration1_test.go

@@ -191,9 +191,6 @@ func Test1ClientServer_exit(t *testing.T) {
 }
 
 func Test1ClientServer_step(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	withTestClient1("testprog", t, func(c *rpc1.RPCClient) {
 		_, err := c.CreateBreakpoint(&api.Breakpoint{FunctionName: "main.helloworld", Line: -1})
 		if err != nil {
@@ -728,7 +725,7 @@ func Test1ClientServer_SetVariable(t *testing.T) {
 
 func Test1ClientServer_FullStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	withTestClient1("goroutinestackprog", t, func(c *rpc1.RPCClient) {
 		_, err := c.CreateBreakpoint(&api.Breakpoint{FunctionName: "main.stacktraceme", Line: -1})
@@ -803,7 +800,7 @@ func Test1ClientServer_FullStacktrace(t *testing.T) {
 
 func Test1Issue355(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// After the target process has terminated should return an error but not crash
 	withTestClient1("continuetestprog", t, func(c *rpc1.RPCClient) {
@@ -863,9 +860,6 @@ func Test1Issue355(t *testing.T) {
 }
 
 func Test1Disasm(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	// Tests that disassembling by PC, range, and current PC all yeld similar results
 	// Tests that disassembly by current PC will return a disassembly containing the instruction at PC
 	// Tests that stepping on a calculated CALL instruction will yield a disassembly that contains the
@@ -909,7 +903,7 @@ func Test1Disasm(t *testing.T) {
 		// look for static call to afunction() on line 29
 		found := false
 		for i := range d3 {
-			if d3[i].Loc.Line == 29 && strings.HasPrefix(d3[i].Text, "call") && d3[i].DestLoc != nil && d3[i].DestLoc.Function != nil && d3[i].DestLoc.Function.Name() == "main.afunction" {
+			if d3[i].Loc.Line == 29 && (strings.HasPrefix(d3[i].Text, "call") || strings.HasPrefix(d3[i].Text, "CALL")) && d3[i].DestLoc != nil && d3[i].DestLoc.Function != nil && d3[i].DestLoc.Function.Name() == "main.afunction" {
 				found = true
 				break
 			}
@@ -954,7 +948,7 @@ func Test1Disasm(t *testing.T) {
 				t.Fatal("Calling StepInstruction() repeatedly did not find the call instruction")
 			}
 
-			if strings.HasPrefix(curinstr.Text, "call") {
+			if strings.HasPrefix(curinstr.Text, "call") || strings.HasPrefix(curinstr.Text, "CALL") {
 				t.Logf("call: %v", curinstr)
 				if curinstr.DestLoc == nil || curinstr.DestLoc.Function == nil {
 					t.Fatalf("Call instruction does not have destination: %v", curinstr)

service/test/integration2_test.go

@@ -246,9 +246,6 @@ func TestClientServer_step(t *testing.T) {
 }
 
 func TestClientServer_stepout(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	protest.AllowRecording(t)
 	withTestClient2("testnextprog", t, func(c service.Client) {
 		_, err := c.CreateBreakpoint(&api.Breakpoint{FunctionName: "main.helloworld", Line: -1})
@@ -807,7 +804,7 @@ func TestClientServer_SetVariable(t *testing.T) {
 
 func TestClientServer_FullStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	protest.AllowRecording(t)
 	withTestClient2("goroutinestackprog", t, func(c service.Client) {
@@ -883,7 +880,7 @@ func TestClientServer_FullStacktrace(t *testing.T) {
 
 func TestIssue355(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support Stacktrace for now")
 	}
 	// After the target process has terminated should return an error but not crash
 	protest.AllowRecording(t)
@@ -948,9 +945,6 @@ func TestIssue355(t *testing.T) {
 }
 
 func TestDisasm(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	// Tests that disassembling by PC, range, and current PC all yeld similar results
 	// Tests that disassembly by current PC will return a disassembly containing the instruction at PC
 	// Tests that stepping on a calculated CALL instruction will yield a disassembly that contains the
@@ -994,7 +988,7 @@ func TestDisasm(t *testing.T) {
 		// look for static call to afunction() on line 29
 		found := false
 		for i := range d3 {
-			if d3[i].Loc.Line == 29 && strings.HasPrefix(d3[i].Text, "call") && d3[i].DestLoc != nil && d3[i].DestLoc.Function != nil && d3[i].DestLoc.Function.Name() == "main.afunction" {
+			if d3[i].Loc.Line == 29 && (strings.HasPrefix(d3[i].Text, "call") || strings.HasPrefix(d3[i].Text, "CALL")) && d3[i].DestLoc != nil && d3[i].DestLoc.Function != nil && d3[i].DestLoc.Function.Name() == "main.afunction" {
 				found = true
 				break
 			}
@@ -1039,7 +1033,7 @@ func TestDisasm(t *testing.T) {
 				t.Fatal("Calling StepInstruction() repeatedly did not find the call instruction")
 			}
 
-			if strings.HasPrefix(curinstr.Text, "call") {
+			if strings.HasPrefix(curinstr.Text, "call") || strings.HasPrefix(curinstr.Text, "CALL") {
 				t.Logf("call: %v", curinstr)
 				if curinstr.DestLoc == nil || curinstr.DestLoc.Function == nil {
 					t.Fatalf("Call instruction does not have destination: %v", curinstr)
@@ -1261,8 +1255,8 @@ func TestClientServer_Issue528(t *testing.T) {
 }
 
 func TestClientServer_FpRegisters(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
+	if runtime.GOARCH != "amd64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("test is valid only on AMD64")
 	}
 	regtests := []struct{ name, value string }{
 		{"ST(0)", "0x3fffe666660000000000"},
@@ -1444,9 +1438,6 @@ func TestClientServer_collectBreakpointInfoError(t *testing.T) {
 }
 
 func TestClientServerConsistentExit(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	// This test is useful because it ensures that Next and Continue operations both
 	// exit with the same exit status and details when the target application terminates.
 	// Other program execution API calls should also behave in the same way.
@@ -1475,9 +1466,6 @@ func TestClientServerConsistentExit(t *testing.T) {
 }
 
 func TestClientServer_StepOutReturn(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	ver, _ := goversion.Parse(runtime.Version())
 	if ver.Major >= 0 && !ver.AfterOrEqual(goversion.GoVersion{1, 10, -1, 0, 0, ""}) {
 		t.Skip("return variables aren't marked on 1.9 or earlier")
@@ -1581,7 +1569,7 @@ func mustHaveDebugCalls(t *testing.T, c service.Client) {
 
 func TestClientServerFunctionCall(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 	withTestClient2("fncall", t, func(c service.Client) {
@@ -1615,7 +1603,7 @@ func TestClientServerFunctionCall(t *testing.T) {
 
 func TestClientServerFunctionCallBadPos(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 	if goversion.VersionAfterOrEqual(runtime.Version(), 1, 12) {
@@ -1645,7 +1633,7 @@ func TestClientServerFunctionCallBadPos(t *testing.T) {
 
 func TestClientServerFunctionCallPanic(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 	withTestClient2("fncall", t, func(c service.Client) {
@@ -1674,7 +1662,7 @@ func TestClientServerFunctionCallPanic(t *testing.T) {
 
 func TestClientServerFunctionCallStacktrace(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support FunctionCall for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 	withTestClient2("fncall", t, func(c service.Client) {
@@ -1748,9 +1736,6 @@ func (c *brokenRPCClient) call(method string, args, reply interface{}) error {
 }
 
 func TestUnknownMethodCall(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	clientConn, _ := startServer("continuetestprog", t)
 	client := &brokenRPCClient{jsonrpc.NewClient(clientConn)}
 	client.call("SetApiVersion", api.SetAPIVersionIn{2}, &api.SetAPIVersionOut{})

service/test/variables_test.go

@@ -1127,7 +1127,7 @@ type testCaseCallFunction struct {
 
 func TestCallFunction(t *testing.T) {
 	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
+		t.Skip("arm64 do not support CallFunction for now")
 	}
 	protest.MustSupportFunctionCalls(t, testBackend)
 
@@ -1412,9 +1412,6 @@ func assertCurrentLocationFunction(p proc.Process, t *testing.T, fnname string)
 }
 
 func TestPluginVariables(t *testing.T) {
-	if runtime.GOARCH == "arm64" {
-		t.Skip("test is not valid on ARM64")
-	}
 	pluginFixtures := protest.WithPlugins(t, protest.AllNonOptimized, "plugin1/", "plugin2/")
 
 	withTestProcessArgs("plugintest2", t, ".", []string{pluginFixtures[0].Path, pluginFixtures[1].Path}, protest.AllNonOptimized, func(p proc.Process, fixture protest.Fixture) {