pkg/cover/backend: remove RestorePC

Now that PCs are 64-bit we don't need RestorePC callback.
Now we can just use PreviousInstructionPC, which does not require
creation of ReportGenerator.

11 files changed, 41 insertions, 40 deletions

diff --git a/pkg/cover/backend/backend.go b/pkg/cover/backend/backend.go
index 5aa6a221c..b390f5cad 100644
--- a/pkg/cover/backend/backend.go
+++ b/pkg/cover/backend/backend.go
@@ -14,7 +14,6 @@ type Impl struct {
 	Symbols         []*Symbol
 	Frames          []Frame
 	Symbolize       func(pcs map[*Module][]uint64) ([]Frame, error)
-	RestorePC       func(pc uint64) uint64
 	CallbackPoints  []uint64
 	PreciseCoverage bool
 }
diff --git a/pkg/cover/backend/dwarf.go b/pkg/cover/backend/dwarf.go
index 3f64cf752..a1f2b3e1e 100644
--- a/pkg/cover/backend/dwarf.go
+++ b/pkg/cover/backend/dwarf.go
@@ -223,19 +223,12 @@ func makeDWARFUnsafe(params *dwarfParams) (*Impl, error) {
 		Symbolize: func(pcs map[*Module][]uint64) ([]Frame, error) {
 			return symbolize(target, &interner, objDir, srcDir, buildDir, splitBuildDelimiters, pcs)
 		},
-		RestorePC:       makeRestorePC(params),
 		CallbackPoints:  allCoverPoints[0],
 		PreciseCoverage: preciseCoverage,
 	}
 	return impl, nil
 }
 
-func makeRestorePC(params *dwarfParams) func(pc uint64) uint64 {
-	return func(pc uint64) uint64 {
-		return PreviousInstructionPC(params.target, pc)
-	}
-}
-
 func buildSymbols(symbols []*Symbol, ranges []pcRange, coverPoints [2][]uint64) []*Symbol {
 	// Assign coverage point PCs to symbols.
 	// Both symbols and coverage points are sorted, so we do it one pass over both.
diff --git a/pkg/cover/backend/gvisor.go b/pkg/cover/backend/gvisor.go
index 65a3da9a2..9d4fc68b3 100644
--- a/pkg/cover/backend/gvisor.go
+++ b/pkg/cover/backend/gvisor.go
@@ -48,9 +48,6 @@ func makeGvisor(target *targets.Target, objDir, srcDir, buildDir string, modules
 	impl := &Impl{
 		Units:  units,
 		Frames: frames,
-		RestorePC: func(pc uint64) uint64 {
-			return pc
-		},
 	}
 	return impl, nil
 }
diff --git a/pkg/cover/backend/pc.go b/pkg/cover/backend/pc.go
index 10462c243..24b4b296e 100644
--- a/pkg/cover/backend/pc.go
+++ b/pkg/cover/backend/pc.go
@@ -9,7 +9,11 @@ import (
 	"github.com/google/syzkaller/sys/targets"
 )
 
-func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
+func PreviousInstructionPC(target *targets.Target, vm string, pc uint64) uint64 {
+	if vm == "gvisor" {
+		// gVisor coverage returns real PCs that don't need adjustment.
+		return pc
+	}
 	offset := instructionLen(target.Arch)
 	pc -= offset
 	// THUMB instructions are 2 or 4 bytes with low bit set.
@@ -20,7 +24,10 @@ func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
 	return pc
 }
 
-func NextInstructionPC(target *targets.Target, pc uint64) uint64 {
+func NextInstructionPC(target *targets.Target, vm string, pc uint64) uint64 {
+	if vm == "gvisor" {
+		return pc
+	}
 	offset := instructionLen(target.Arch)
 	pc += offset
 	// THUMB instructions are 2 or 4 bytes with low bit set.
diff --git a/pkg/cover/report_test.go b/pkg/cover/report_test.go
index 07ae439ac..7ce519c83 100644
--- a/pkg/cover/report_test.go
+++ b/pkg/cover/report_test.go
@@ -348,7 +348,7 @@ func generateReport(t *testing.T, target *targets.Target, test *Test) (*reports,
 			if err != nil {
 				t.Fatal(err)
 			}
-			pcs = append(pcs, backend.PreviousInstructionPC(target, pc))
+			pcs = append(pcs, backend.PreviousInstructionPC(target, "", pc))
 			t.Logf("using exact coverage PC 0x%x", pcs[0])
 		} else if target.OS == runtime.GOOS && (target.Arch == runtime.GOARCH || target.VMArch == runtime.GOARCH) {
 			t.Fatal(err)
diff --git a/syz-manager/cover.go b/syz-manager/cover.go
index 0009ea1c8..0e396700b 100644
--- a/syz-manager/cover.go
+++ b/syz-manager/cover.go
@@ -7,6 +7,7 @@ import (
 	"sync"
 
 	"github.com/google/syzkaller/pkg/cover"
+	"github.com/google/syzkaller/pkg/cover/backend"
 	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/mgrconfig"
 )
@@ -36,10 +37,11 @@ func resetReportGenerator() {
 	cachedRepGen = nil
 }
 
-func coverToPCs(rg *cover.ReportGenerator, cov []uint64) []uint64 {
+func coverToPCs(cfg *mgrconfig.Config, cov []uint64) []uint64 {
 	pcs := make([]uint64, 0, len(cov))
 	for _, pc := range cov {
-		pcs = append(pcs, rg.RestorePC(pc))
+		prev := backend.PreviousInstructionPC(cfg.SysTarget, cfg.Type, pc)
+		pcs = append(pcs, prev)
 	}
 	return pcs
 }
diff --git a/syz-manager/covfilter.go b/syz-manager/covfilter.go
index 53fc03070..2bf3adeec 100644
--- a/syz-manager/covfilter.go
+++ b/syz-manager/covfilter.go
@@ -5,7 +5,6 @@ package main
 
 import (
 	"bufio"
-	"encoding/binary"
 	"fmt"
 	"os"
 	"regexp"
@@ -16,7 +15,6 @@ import (
 	"github.com/google/syzkaller/pkg/cover/backend"
 	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/mgrconfig"
-	"github.com/google/syzkaller/sys/targets"
 )
 
 func createCoverageFilter(cfg *mgrconfig.Config, modules []cover.KernelModule) (
@@ -137,7 +135,7 @@ func covFilterAddRawPCs(pcs map[uint64]uint32, rawPCsFiles []string) error {
 	return nil
 }
 
-func createCoverageBitmap(target *targets.Target, pcs map[uint64]uint32) []byte {
+func createCoverageBitmap(cfg *mgrconfig.Config, pcs map[uint64]uint32) []byte {
 	// Return nil if filtering is not used.
 	if len(pcs) == 0 {
 		return nil
@@ -148,17 +146,14 @@ func createCoverageBitmap(target *targets.Target, pcs map[uint64]uint32) []byte
 	// and a bitmap with size ((covFilterSize>>4)/8+2 bytes follow them.
 	// 8-bit = 1-byte
 	data := make([]byte, 12+((size>>4)/8+2))
-	order := binary.ByteOrder(binary.BigEndian)
-	if target.LittleEndian {
-		order = binary.LittleEndian
-	}
+	order := cfg.SysTarget.HostEndian
 	order.PutUint64(data, start)
 	order.PutUint32(data[8:], size)
 
 	bitmap := data[12:]
 	for pc := range pcs {
 		// The lowest 4-bit is dropped.
-		pc = backend.NextInstructionPC(target, pc)
+		pc = backend.NextInstructionPC(cfg.SysTarget, cfg.Type, pc)
 		pc = (pc - start) >> 4
 		bitmap[pc/8] |= (1 << (pc % 8))
 	}
diff --git a/syz-manager/covfilter_test.go b/syz-manager/covfilter_test.go
index d6165c19b..5c0bbbaf9 100644
--- a/syz-manager/covfilter_test.go
+++ b/syz-manager/covfilter_test.go
@@ -6,6 +6,7 @@ package main
 import (
 	"testing"
 
+	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/sys/targets"
 )
 
@@ -16,7 +17,12 @@ func TestCreateBitmap(t *testing.T) {
 	}
 	target := targets.Get("test", "64")
 	order := target.HostEndian
-	bitmap := createCoverageBitmap(target, pcs)
+	cfg := &mgrconfig.Config{
+		Derived: mgrconfig.Derived{
+			SysTarget: target,
+		},
+	}
+	bitmap := createCoverageBitmap(cfg, pcs)
 	start := order.Uint64(bitmap[0:])
 	size := order.Uint32(bitmap[8:])
 	if start != 0x81000002 || size != 0x20001b {
@@ -38,24 +44,28 @@ func TestCreateBitmap(t *testing.T) {
 		0:          1,
 		0xffffffff: 1,
 	}
-	createCoverageBitmap(target, pcs)
+	createCoverageBitmap(cfg, pcs)
 	pcs = map[uint64]uint32{
 		0x81000000: 1,
 		0x81000100: 1,
 	}
-	createCoverageBitmap(target, pcs)
+	createCoverageBitmap(cfg, pcs)
 	pcs = map[uint64]uint32{
 		0x81000002: 1,
 		0x81000010: 1,
 		0x81000102: 1,
 	}
-	createCoverageBitmap(target, pcs)
+	createCoverageBitmap(cfg, pcs)
 }
 
 func TestNilCoverageBitmap(t *testing.T) {
 	pcs := map[uint64]uint32(nil)
-	target := targets.Get("test", "64")
-	bitmap := createCoverageBitmap(target, pcs)
+	cfg := &mgrconfig.Config{
+		Derived: mgrconfig.Derived{
+			SysTarget: targets.Get("test", "64"),
+		},
+	}
+	bitmap := createCoverageBitmap(cfg, pcs)
 	if bitmap != nil {
 		t.Errorf("created a bitmap on nil pcs")
 	}
diff --git a/syz-manager/http.go b/syz-manager/http.go
index 67fed3fdb..3eb674051 100644
--- a/syz-manager/http.go
+++ b/syz-manager/http.go
@@ -288,13 +288,13 @@ func (mgr *Manager) httpCoverCover(w http.ResponseWriter, r *http.Request, funcF
 			progs = append(progs, cover.Prog{
 				Sig:  sig,
 				Data: string(inp.ProgData),
-				PCs:  coverToPCs(rg, inp.Updates[updateID].RawCover),
+				PCs:  coverToPCs(mgr.cfg, inp.Updates[updateID].RawCover),
 			})
 		} else {
 			progs = append(progs, cover.Prog{
 				Sig:  sig,
 				Data: string(inp.ProgData),
-				PCs:  coverToPCs(rg, inp.Cover),
+				PCs:  coverToPCs(mgr.cfg, inp.Cover),
 			})
 		}
 	} else {
@@ -306,7 +306,7 @@ func (mgr *Manager) httpCoverCover(w http.ResponseWriter, r *http.Request, funcF
 			progs = append(progs, cover.Prog{
 				Sig:  inp.Sig,
 				Data: string(inp.ProgData),
-				PCs:  coverToPCs(rg, inp.Cover),
+				PCs:  coverToPCs(mgr.cfg, inp.Cover),
 			})
 		}
 	}
diff --git a/syz-manager/rpc.go b/syz-manager/rpc.go
index 7832751c2..7acb030df 100644
--- a/syz-manager/rpc.go
+++ b/syz-manager/rpc.go
@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/pkg/cover"
+	"github.com/google/syzkaller/pkg/cover/backend"
 	"github.com/google/syzkaller/pkg/flatrpc"
 	"github.com/google/syzkaller/pkg/fuzzer/queue"
 	"github.com/google/syzkaller/pkg/ipc"
@@ -249,7 +250,7 @@ func (serv *RPCServer) handshake(conn *flatrpc.Conn) (string, []byte, *cover.Can
 	canonicalizer := serv.canonicalModules.NewInstance(modules)
 	instCoverFilter := canonicalizer.DecanonicalizeFilter(serv.execCoverFilter)
 	infoReply := &flatrpc.InfoReply{
-		CoverFilter: createCoverageBitmap(serv.cfg.SysTarget, instCoverFilter),
+		CoverFilter: createCoverageBitmap(serv.cfg, instCoverFilter),
 	}
 	if err := flatrpc.Send(conn, infoReply); err != nil {
 		return "", nil, nil, err
@@ -621,13 +622,10 @@ func (serv *RPCServer) updateCoverFilter(newCover []uint64) {
 	if len(newCover) == 0 || serv.coverFilter == nil {
 		return
 	}
-	rg, _ := getReportGenerator(serv.cfg, serv.modules)
-	if rg == nil {
-		return
-	}
 	filtered := 0
 	for _, pc := range newCover {
-		if serv.coverFilter[rg.RestorePC(pc)] != 0 {
+		pc = backend.PreviousInstructionPC(serv.cfg.SysTarget, serv.cfg.Type, pc)
+		if serv.coverFilter[pc] != 0 {
 			filtered++
 		}
 	}
diff --git a/tools/syz-execprog/execprog.go b/tools/syz-execprog/execprog.go
index 43146a170..68d7db128 100644
--- a/tools/syz-execprog/execprog.go
+++ b/tools/syz-execprog/execprog.go
@@ -297,7 +297,7 @@ func (ctx *Context) dumpCallCoverage(coverFile string, info *flatrpc.CallInfo) {
 	}
 	buf := new(bytes.Buffer)
 	for _, pc := range info.Cover {
-		prev := backend.PreviousInstructionPC(ctx.sysTarget, pc)
+		prev := backend.PreviousInstructionPC(ctx.sysTarget, "", pc)
 		fmt.Fprintf(buf, "0x%x\n", prev)
 	}
 	err := osutil.WriteFile(coverFile, buf.Bytes())