all: adapt all cover and sig to 64bit

Taken some arm64 devices for example:
kaslr_offset is diff at bits 12-40, and kernel modules are loaded at 2GB space,
so we have `ffffffd342e10000 T _stext` where uppper 32bit is ffffffd3. However,
if we check modules range, the 1st module is loaded at 0xffffffd2eeb2a000,
while the last module is loaded at 0xffffffd2f42c4000.
We can see the upper 32bits are diff for core kernel and modules.

If we use current 32bits for covered PC, we will get wrong module address
recovered.

So we need to move to 64bit cover and signal:
- change cover/sig to 64bit to fit for syz-executor change
- remove kernel upper base logic as kernel upper base is not a constant when
  kaslr enabled for core kernel and modules.
- remove unused pcBase

2 files changed, 18 insertions, 18 deletions

diff --git a/pkg/signal/signal.go b/pkg/signal/signal.go
index 10a1ef0cb..5f6da48cb 100644
--- a/pkg/signal/signal.go
+++ b/pkg/signal/signal.go
@@ -7,7 +7,7 @@ package signal
 import "math/rand"
 
 type (
-	elemType uint32
+	elemType uint64
 	prioType int8
 )
 
@@ -50,7 +50,7 @@ func (s *Signal) Split(n int) Signal {
 	return c
 }
 
-func FromRaw(raw []uint32, prio uint8) Signal {
+func FromRaw(raw []uint64, prio uint8) Signal {
 	if len(raw) == 0 {
 		return nil
 	}
@@ -78,7 +78,7 @@ func (s Signal) Diff(s1 Signal) Signal {
 	return res
 }
 
-func (s Signal) DiffRaw(raw []uint32, prio uint8) Signal {
+func (s Signal) DiffRaw(raw []uint64, prio uint8) Signal {
 	var res Signal
 	for _, e := range raw {
 		if p, ok := s[elemType(e)]; ok && p >= prioType(prio) {
@@ -161,8 +161,8 @@ func (s Signal) RandomSubset(r *rand.Rand, size int) Signal {
 
 // FilterRaw returns a subset of original raw elements that either are not present in ignore,
 // or coincides with the one in alwaysTake.
-func FilterRaw(raw []uint32, ignore, alwaysTake Signal) []uint32 {
-	var ret []uint32
+func FilterRaw(raw []uint64, ignore, alwaysTake Signal) []uint64 {
+	var ret []uint64
 	for _, e := range raw {
 		if _, ok := alwaysTake[elemType(e)]; ok {
 			ret = append(ret, e)
@@ -174,8 +174,8 @@ func FilterRaw(raw []uint32, ignore, alwaysTake Signal) []uint32 {
 }
 
 // DiffFromRaw returns a subset of the raw elements that is not present in Signal.
-func (s Signal) DiffFromRaw(raw []uint32) []uint32 {
-	var ret []uint32
+func (s Signal) DiffFromRaw(raw []uint64) []uint64 {
+	var ret []uint64
 	for _, e := range raw {
 		if _, ok := s[elemType(e)]; !ok {
 			ret = append(ret, e)
@@ -184,10 +184,10 @@ func (s Signal) DiffFromRaw(raw []uint32) []uint32 {
 	return ret
 }
 
-func (s Signal) ToRaw() []uint32 {
-	var raw []uint32
+func (s Signal) ToRaw() []uint64 {
+	var raw []uint64
 	for e := range s {
-		raw = append(raw, uint32(e))
+		raw = append(raw, uint64(e))
 	}
 	return raw
 }
diff --git a/pkg/signal/signal_test.go b/pkg/signal/signal_test.go
index efd53d2ea..52b91fc19 100644
--- a/pkg/signal/signal_test.go
+++ b/pkg/signal/signal_test.go
@@ -13,7 +13,7 @@ import (
 
 func TestRandomSubset(t *testing.T) {
 	r := rand.New(testutil.RandSource(t))
-	base := FromRaw([]uint32{0, 1, 2, 3, 4}, 0)
+	base := FromRaw([]uint64{0, 1, 2, 3, 4}, 0)
 	var s Signal
 	for i := 0; i < 1000 && s.Len() < base.Len(); i++ {
 		delta := base.RandomSubset(r, 1)
@@ -24,18 +24,18 @@ func TestRandomSubset(t *testing.T) {
 }
 
 func TestSubtract(t *testing.T) {
-	base := FromRaw([]uint32{0, 1, 2, 3, 4}, 0)
+	base := FromRaw([]uint64{0, 1, 2, 3, 4}, 0)
 	assert.Equal(t, 5, base.Len())
-	base.Subtract(FromRaw([]uint32{0}, 0))
+	base.Subtract(FromRaw([]uint64{0}, 0))
 	assert.Equal(t, 4, base.Len())
-	base.Subtract(FromRaw([]uint32{1}, 0))
+	base.Subtract(FromRaw([]uint64{1}, 0))
 	assert.Equal(t, 3, base.Len())
 }
 
 func TestIntersectsWith(t *testing.T) {
-	base := FromRaw([]uint32{0, 1, 2, 3, 4}, 1)
-	assert.True(t, base.IntersectsWith(FromRaw([]uint32{0, 5, 10}, 1)))
-	assert.False(t, base.IntersectsWith(FromRaw([]uint32{5, 10, 15}, 1)))
+	base := FromRaw([]uint64{0, 1, 2, 3, 4}, 1)
+	assert.True(t, base.IntersectsWith(FromRaw([]uint64{0, 5, 10}, 1)))
+	assert.False(t, base.IntersectsWith(FromRaw([]uint64{5, 10, 15}, 1)))
 	// The other signal has a lower priority.
-	assert.False(t, base.IntersectsWith(FromRaw([]uint32{0, 1, 2}, 0)))
+	assert.False(t, base.IntersectsWith(FromRaw([]uint64{0, 1, 2}, 0)))
 }