pkg,service: remove unnecessary convertions (#3564)

alexandear · web-flow · commit 938cb6e9d8e5 · 2023-11-14T16:36:55.000+01:00
diff --git a/pkg/dwarf/dwarfbuilder/info.go b/pkg/dwarf/dwarfbuilder/info.go
@@ -167,8 +167,8 @@ func (b *Builder) Attr(attr dwarf.Attr, val interface{}) dwarf.Offset {
 		binary.Write(&b.loc, binary.LittleEndian, uint64(0))
 
 		for _, locentry := range x {
-			binary.Write(&b.loc, binary.LittleEndian, uint64(locentry.Lowpc))
-			binary.Write(&b.loc, binary.LittleEndian, uint64(locentry.Highpc))
+			binary.Write(&b.loc, binary.LittleEndian, locentry.Lowpc)
+			binary.Write(&b.loc, binary.LittleEndian, locentry.Highpc)
 			binary.Write(&b.loc, binary.LittleEndian, uint16(len(locentry.Loc)))
 			b.loc.Write(locentry.Loc)
 		}
diff --git a/pkg/dwarf/leb128/decode.go b/pkg/dwarf/leb128/decode.go
@@ -67,7 +67,7 @@ func DecodeSigned(buf Reader) (int64, uint32) {
 		}
 		length++
 
-		result |= int64((int64(b) & 0x7f) << shift)
+		result |= (int64(b) & 0x7f) << shift
 		shift += 7
 		if b&0x80 == 0 {
 			break
diff --git a/pkg/dwarf/line/line_parser.go b/pkg/dwarf/line/line_parser.go
@@ -132,16 +132,16 @@ func parseDebugLinePrologue(dbl *DebugLineInfo, buf *bytes.Buffer) {
 	}
 
 	p.Length = binary.LittleEndian.Uint32(buf.Next(4))
-	p.MinInstrLength = uint8(buf.Next(1)[0])
+	p.MinInstrLength = buf.Next(1)[0]
 	if p.Version >= 4 {
-		p.MaxOpPerInstr = uint8(buf.Next(1)[0])
+		p.MaxOpPerInstr = buf.Next(1)[0]
 	} else {
 		p.MaxOpPerInstr = 1
 	}
-	p.InitialIsStmt = uint8(buf.Next(1)[0])
+	p.InitialIsStmt = buf.Next(1)[0]
 	p.LineBase = int8(buf.Next(1)[0])
-	p.LineRange = uint8(buf.Next(1)[0])
-	p.OpcodeBase = uint8(buf.Next(1)[0])
+	p.LineRange = buf.Next(1)[0]
+	p.OpcodeBase = buf.Next(1)[0]
 
 	p.StdOpLengths = make([]uint8, p.OpcodeBase-1)
 	binary.Read(buf, binary.LittleEndian, &p.StdOpLengths)
diff --git a/pkg/dwarf/line/state_machine.go b/pkg/dwarf/line/state_machine.go
@@ -423,7 +423,7 @@ func (sm *StateMachine) next() error {
 
 func execSpecialOpcode(sm *StateMachine, instr byte) {
 	var (
-		opcode  = uint8(instr)
+		opcode  = instr
 		decoded = opcode - sm.dbl.Prologue.OpcodeBase
 	)
 
diff --git a/pkg/dwarf/loclist/dwarf2_loclist.go b/pkg/dwarf/loclist/dwarf2_loclist.go
@@ -87,7 +87,7 @@ func (rdr *Dwarf2Reader) oneAddr() uint64 {
 		}
 		return uint64(addr)
 	case 8:
-		addr := uint64(binary.LittleEndian.Uint64(rdr.read(rdr.ptrSz)))
+		addr := binary.LittleEndian.Uint64(rdr.read(rdr.ptrSz))
 		return addr
 	default:
 		panic("bad address size")
diff --git a/pkg/dwarf/op/op.go b/pkg/dwarf/op/op.go
@@ -208,7 +208,7 @@ func callframecfa(opcode Opcode, ctxt *context) error {
 	if ctxt.CFA == 0 {
 		return errors.New("could not retrieve CFA for current PC")
 	}
-	ctxt.stack = append(ctxt.stack, int64(ctxt.CFA))
+	ctxt.stack = append(ctxt.stack, ctxt.CFA)
 	return nil
 }
 
@@ -373,7 +373,7 @@ func pick(opcode Opcode, ctxt *context) error {
 	default:
 		panic("internal error")
 	}
-	idx := len(ctxt.stack) - 1 - int(uint8(n))
+	idx := len(ctxt.stack) - 1 - int(n)
 	if idx < 0 || idx >= len(ctxt.stack) {
 		return ErrStackIndexOutOfBounds
 	}
diff --git a/pkg/elfwriter/writer.go b/pkg/elfwriter/writer.go
@@ -58,7 +58,7 @@ func New(w WriteCloserSeeker, fhdr *elf.FileHeader) *Writer {
 	}
 
 	// e_ident
-	r.Write([]byte{0x7f, 'E', 'L', 'F', byte(fhdr.Class), byte(fhdr.Data), byte(fhdr.Version), byte(fhdr.OSABI), byte(fhdr.ABIVersion), 0, 0, 0, 0, 0, 0, 0})
+	r.Write([]byte{0x7f, 'E', 'L', 'F', byte(fhdr.Class), byte(fhdr.Data), byte(fhdr.Version), byte(fhdr.OSABI), fhdr.ABIVersion, 0, 0, 0, 0, 0, 0, 0})
 
 	r.u16(uint16(fhdr.Type))    // e_type
 	r.u16(uint16(fhdr.Machine)) // e_machine
diff --git a/pkg/locspec/locations.go b/pkg/locspec/locations.go
@@ -311,7 +311,7 @@ func (loc *AddrLocationSpec) Find(t *proc.Target, _ []string, scope *proc.EvalSc
 		addr, _ := constant.Uint64Val(v.Value)
 		return []api.Location{{PC: addr}}, "", nil
 	case reflect.Func:
-		fn := scope.BinInfo.PCToFunc(uint64(v.Base))
+		fn := scope.BinInfo.PCToFunc(v.Base)
 		pc, err := proc.FirstPCAfterPrologue(t, fn, false)
 		if err != nil {
 			return nil, "", err
diff --git a/pkg/proc/amd64_arch.go b/pkg/proc/amd64_arch.go
@@ -150,7 +150,7 @@ func amd64SwitchStack(it *stackIterator, _ *op.DwarfRegisters) bool {
 		// switches from the goroutine stack to the system stack.
 		// Since we are unwinding the stack from callee to caller we have to switch
 		// from the system stack to the goroutine stack.
-		off, _ := readIntRaw(it.mem, uint64(it.regs.SP()+amd64cgocallSPOffsetSaveSlot), int64(it.bi.Arch.PtrSize())) // reads "offset of SP from StackHi" from where runtime.asmcgocall saved it
+		off, _ := readIntRaw(it.mem, it.regs.SP()+amd64cgocallSPOffsetSaveSlot, int64(it.bi.Arch.PtrSize())) // reads "offset of SP from StackHi" from where runtime.asmcgocall saved it
 		oldsp := it.regs.SP()
 		it.regs.Reg(it.regs.SPRegNum).Uint64Val = uint64(int64(it.stackhi) - off)
 
@@ -190,7 +190,7 @@ func amd64SwitchStack(it *stackIterator, _ *op.DwarfRegisters) bool {
 		// entering the system stack
 		it.regs.Reg(it.regs.SPRegNum).Uint64Val = it.g0_sched_sp
 		// reads the previous value of g0.sched.sp that runtime.cgocallback_gofunc saved on the stack
-		it.g0_sched_sp, _ = readUintRaw(it.mem, uint64(it.regs.SP()), int64(it.bi.Arch.PtrSize()))
+		it.g0_sched_sp, _ = readUintRaw(it.mem, it.regs.SP(), int64(it.bi.Arch.PtrSize()))
 		it.top = false
 		callFrameRegs, ret, retaddr := it.advanceRegs()
 		frameOnSystemStack := it.newStackframe(ret, retaddr)
@@ -409,7 +409,7 @@ func formatX87Reg(b []byte) string {
 		return fmt.Sprintf("%#x", b)
 	}
 	mantissa := binary.LittleEndian.Uint64(b[:8])
-	exponent := uint16(binary.LittleEndian.Uint16(b[8:]))
+	exponent := binary.LittleEndian.Uint16(b[8:])
 
 	var f float64
 	fset := false
diff --git a/pkg/proc/arm64_arch.go b/pkg/proc/arm64_arch.go
@@ -174,7 +174,7 @@ func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegisters) bool
 			// Entering the system stack.
 			it.regs.Reg(callFrameRegs.SPRegNum).Uint64Val = it.g0_sched_sp
 			// Reads the previous value of g0.sched.sp that runtime.cgocallback_gofunc saved on the stack.
-			it.g0_sched_sp, _ = readUintRaw(it.mem, uint64(it.regs.SP()+prevG0schedSPOffsetSaveSlot), int64(it.bi.Arch.PtrSize()))
+			it.g0_sched_sp, _ = readUintRaw(it.mem, it.regs.SP()+prevG0schedSPOffsetSaveSlot, int64(it.bi.Arch.PtrSize()))
 			it.top = false
 			callFrameRegs, ret, retaddr := it.advanceRegs()
 			frameOnSystemStack := it.newStackframe(ret, retaddr)
@@ -195,7 +195,7 @@ func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegisters) bool
 			// switches from the goroutine stack to the system stack.
 			// Since we are unwinding the stack from callee to caller we have to switch
 			// from the system stack to the goroutine stack.
-			off, _ := readIntRaw(it.mem, uint64(it.regs.SP()+arm64cgocallSPOffsetSaveSlot),
+			off, _ := readIntRaw(it.mem, it.regs.SP()+arm64cgocallSPOffsetSaveSlot,
 				int64(it.bi.Arch.PtrSize()))
 			oldsp := it.regs.SP()
 			newsp := uint64(int64(it.stackhi) - off)
@@ -239,20 +239,20 @@ func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegisters) bool
 			bpoff = 22
 			lroff = 23
 		}
-		newsp, _ := readUintRaw(it.mem, uint64(it.regs.SP()+8*24), int64(it.bi.Arch.PtrSize()))
-		newbp, _ := readUintRaw(it.mem, uint64(it.regs.SP()+8*bpoff), int64(it.bi.Arch.PtrSize()))
-		newlr, _ := readUintRaw(it.mem, uint64(it.regs.SP()+8*lroff), int64(it.bi.Arch.PtrSize()))
+		newsp, _ := readUintRaw(it.mem, it.regs.SP()+8*24, int64(it.bi.Arch.PtrSize()))
+		newbp, _ := readUintRaw(it.mem, it.regs.SP()+8*bpoff, int64(it.bi.Arch.PtrSize()))
+		newlr, _ := readUintRaw(it.mem, it.regs.SP()+8*lroff, int64(it.bi.Arch.PtrSize()))
 		if it.regs.Reg(it.regs.BPRegNum) != nil {
-			it.regs.Reg(it.regs.BPRegNum).Uint64Val = uint64(newbp)
+			it.regs.Reg(it.regs.BPRegNum).Uint64Val = newbp
 		} else {
 			reg, _ := it.readRegisterAt(it.regs.BPRegNum, it.regs.SP()+8*bpoff)
 			it.regs.AddReg(it.regs.BPRegNum, reg)
 		}
-		it.regs.Reg(it.regs.LRRegNum).Uint64Val = uint64(newlr)
+		it.regs.Reg(it.regs.LRRegNum).Uint64Val = newlr
 		if linux {
-			it.regs.Reg(it.regs.SPRegNum).Uint64Val = uint64(newbp)
+			it.regs.Reg(it.regs.SPRegNum).Uint64Val = newbp
 		} else {
-			it.regs.Reg(it.regs.SPRegNum).Uint64Val = uint64(newsp)
+			it.regs.Reg(it.regs.SPRegNum).Uint64Val = newsp
 		}
 		it.pc = newlr
 		return true
@@ -299,7 +299,7 @@ func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegisters) bool
 		// switches from the goroutine stack to the system stack.
 		// Since we are unwinding the stack from callee to caller we have to switch
 		// from the system stack to the goroutine stack.
-		off, _ := readIntRaw(it.mem, uint64(callFrameRegs.SP()+arm64cgocallSPOffsetSaveSlot), int64(it.bi.Arch.PtrSize()))
+		off, _ := readIntRaw(it.mem, callFrameRegs.SP()+arm64cgocallSPOffsetSaveSlot, int64(it.bi.Arch.PtrSize()))
 		oldsp := callFrameRegs.SP()
 		newsp := uint64(int64(it.stackhi) - off)
 
@@ -334,7 +334,7 @@ func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegisters) bool
 		callFrameRegs.Reg(callFrameRegs.SPRegNum).Uint64Val = it.g0_sched_sp
 		// reads the previous value of g0.sched.sp that runtime.cgocallback_gofunc saved on the stack
 
-		it.g0_sched_sp, _ = readUintRaw(it.mem, uint64(callFrameRegs.SP()+prevG0schedSPOffsetSaveSlot), int64(it.bi.Arch.PtrSize()))
+		it.g0_sched_sp, _ = readUintRaw(it.mem, callFrameRegs.SP()+prevG0schedSPOffsetSaveSlot, int64(it.bi.Arch.PtrSize()))
 		it.systemstack = true
 		return false
 	}
diff --git a/pkg/proc/arm64_disasm.go b/pkg/proc/arm64_disasm.go
@@ -63,7 +63,7 @@ func resolveCallArgARM64(inst *arm64asm.Inst, instAddr uint64, currentGoroutine
 			return nil
 		}
 	case arm64asm.PCRel:
-		pc = uint64(instAddr) + uint64(arg)
+		pc = instAddr + uint64(arg)
 	default:
 		return nil
 	}
diff --git a/pkg/proc/bininfo.go b/pkg/proc/bininfo.go
@@ -914,7 +914,7 @@ func (bi *BinaryInfo) AddImage(path string, addr uint64) error {
 
 // moduleDataToImage finds the image corresponding to the given module data object.
 func (bi *BinaryInfo) moduleDataToImage(md *moduleData) *Image {
-	fn := bi.PCToFunc(uint64(md.text))
+	fn := bi.PCToFunc(md.text)
 	if fn != nil {
 		return bi.funcToImage(fn)
 	}
diff --git a/pkg/proc/breakpoints.go b/pkg/proc/breakpoints.go
@@ -704,7 +704,7 @@ func (t *Target) setBreakpointInternal(logicalID int, addr uint64, kind Breakpoi
 		return bp, nil
 	}
 
-	f, l, fn := t.BinInfo().PCToLine(uint64(addr))
+	f, l, fn := t.BinInfo().PCToLine(addr)
 
 	fnName := ""
 	if fn != nil {
diff --git a/pkg/proc/core/core.go b/pkg/proc/core/core.go
@@ -340,7 +340,7 @@ func (t *thread) Breakpoint() *proc.BreakpointState {
 
 // ThreadID returns the ID for this thread.
 func (t *thread) ThreadID() int {
-	return int(t.th.pid())
+	return t.th.pid()
 }
 
 // Registers returns the current value of the registers for this thread.
diff --git a/pkg/proc/core/minidump/minidump.go b/pkg/proc/core/minidump/minidump.go
@@ -186,10 +186,10 @@ func (m *MemoryRange) ReadMemory(buf []byte, addr uint64) (int, error) {
 	if len(buf) == 0 {
 		return 0, nil
 	}
-	if (uint64(addr) < m.Addr) || (uint64(addr)+uint64(len(buf)) > m.Addr+uint64(len(m.Data))) {
+	if (addr < m.Addr) || (addr+uint64(len(buf)) > m.Addr+uint64(len(m.Data))) {
 		return 0, io.EOF
 	}
-	copy(buf, m.Data[uint64(addr)-m.Addr:])
+	copy(buf, m.Data[addr-m.Addr:])
 	return len(buf), nil
 }
 
diff --git a/pkg/proc/disasm.go b/pkg/proc/disasm.go
@@ -139,7 +139,7 @@ func disassemble(memrw MemoryReadWriter, regs Registers, breakpoints *Breakpoint
 		return nil, err
 	}
 
-	r := make([]AsmInstruction, 0, len(mem)/int(bi.Arch.MaxInstructionLength()))
+	r := make([]AsmInstruction, 0, len(mem)/bi.Arch.MaxInstructionLength())
 	pc := startAddr
 
 	var curpc uint64
diff --git a/pkg/proc/dwarf_expr_test.go b/pkg/proc/dwarf_expr_test.go
@@ -65,10 +65,10 @@ func newFakeMemory(base uint64, contents ...interface{}) *fakeMemory {
 }
 
 func (mem *fakeMemory) ReadMemory(data []byte, addr uint64) (int, error) {
-	if uint64(addr) < mem.base {
+	if addr < mem.base {
 		return 0, fmt.Errorf("read out of bounds %d %#x", len(data), addr)
 	}
-	start := uint64(addr) - mem.base
+	start := addr - mem.base
 	end := uint64(len(data)) + start
 	if end > uint64(len(mem.data)) {
 		panic(fmt.Errorf("read out of bounds %d %#x", len(data), addr))
@@ -78,10 +78,10 @@ func (mem *fakeMemory) ReadMemory(data []byte, addr uint64) (int, error) {
 }
 
 func (mem *fakeMemory) WriteMemory(addr uint64, data []byte) (int, error) {
-	if uint64(addr) < mem.base {
+	if addr < mem.base {
 		return 0, fmt.Errorf("write out of bounds %d %#x", len(data), addr)
 	}
-	start := uint64(addr) - mem.base
+	start := addr - mem.base
 	end := uint64(len(data)) + start
 	if end > uint64(len(mem.data)) {
 		panic(fmt.Errorf("write out of bounds %d %#x", len(data), addr))
@@ -217,7 +217,7 @@ func TestDwarfExprComposite(t *testing.T) {
 
 	mainfn := bi.LookupFunc()["main.main"][0]
 
-	mem := newFakeMemory(fakeCFA(), uint64(0), uint64(0), uint16(testCases["pair.v"]), []byte(stringVal))
+	mem := newFakeMemory(fakeCFA(), uint64(0), uint64(0), testCases["pair.v"], []byte(stringVal))
 	var regs linutil.AMD64Registers
 	regs.Regs = &linutil.AMD64PtraceRegs{}
 	regs.Regs.Rax = uint64(len(stringVal))
diff --git a/pkg/proc/eval.go b/pkg/proc/eval.go
@@ -553,7 +553,7 @@ func (scope *EvalScope) setValue(dstv, srcv *Variable, srcExpr string) error {
 		if srcv.Base == 0 && srcv.Len > 0 && srcv.Flags&VariableConstant != 0 {
 			return errFuncCallNotAllowedStrAlloc
 		}
-		return dstv.writeString(uint64(srcv.Len), uint64(srcv.Base))
+		return dstv.writeString(uint64(srcv.Len), srcv.Base)
 	}
 
 	// slice assignment (this is not handled by the writeCopy below so that
@@ -564,7 +564,7 @@ func (scope *EvalScope) setValue(dstv, srcv *Variable, srcExpr string) error {
 
 	// allow any integer to be converted to any pointer
 	if t, isptr := dstv.RealType.(*godwarf.PtrType); isptr {
-		return dstv.writeUint(uint64(srcv.Children[0].Addr), int64(t.ByteSize))
+		return dstv.writeUint(srcv.Children[0].Addr, t.ByteSize)
 	}
 
 	// byte-by-byte copying for everything else, but the source must be addressable
@@ -1251,7 +1251,7 @@ func (scope *EvalScope) evalTypeCast(op *evalop.TypeCast, stack *evalStack) {
 			stack.push(v)
 			return
 		case reflect.Ptr:
-			v.Value = constant.MakeUint64(uint64(argv.Children[0].Addr))
+			v.Value = constant.MakeUint64(argv.Children[0].Addr)
 			stack.push(v)
 			return
 		}
@@ -2552,7 +2552,7 @@ func (v *Variable) reslice(low int64, high int64) (*Variable, error) {
 		return nil, fmt.Errorf("index out of bounds")
 	}
 
-	base := v.Base + uint64(int64(low)*v.stride)
+	base := v.Base + uint64(low*v.stride)
 	len := high - low
 
 	if high-low < 0 {
diff --git a/pkg/proc/fncall.go b/pkg/proc/fncall.go
@@ -483,7 +483,7 @@ func funcCallEvalFuncExpr(scope *EvalScope, stack *evalStack, fncall *functionCa
 	if fnvar.Base == 0 {
 		return errors.New("nil pointer dereference")
 	}
-	fncall.fn = bi.PCToFunc(uint64(fnvar.Base))
+	fncall.fn = bi.PCToFunc(fnvar.Base)
 	if fncall.fn == nil {
 		return fmt.Errorf("could not find DIE for function %q", exprToString(fncall.expr.Fun))
 	}
@@ -558,7 +558,7 @@ func funcCallCopyOneArg(scope *EvalScope, fncall *functionCallState, actualArg *
 			return err
 		}
 	} else {
-		formalArgVar = newVariable(formalArg.name, uint64(formalArg.off+int64(formalScope.Regs.CFA)), formalArg.typ, scope.BinInfo, scope.Mem)
+		formalArgVar = newVariable(formalArg.name, uint64(formalArg.off+formalScope.Regs.CFA), formalArg.typ, scope.BinInfo, scope.Mem)
 	}
 	if err := scope.setValue(formalArgVar, actualArg, actualArg.Name); err != nil {
 		return err
@@ -684,7 +684,7 @@ func funcCallArgRegABI(fn *Function, bi *BinaryInfo, entry reader.Variable, argn
 
 // alignAddr rounds up addr to a multiple of align. Align must be a power of 2.
 func alignAddr(addr, align int64) int64 {
-	return (addr + int64(align-1)) &^ int64(align-1)
+	return (addr + align - 1) &^ (align - 1)
 }
 
 func escapeCheck(v *Variable, name string, stack stack) error {
@@ -733,7 +733,7 @@ func escapeCheck(v *Variable, name string, stack stack) error {
 }
 
 func escapeCheckPointer(addr uint64, name string, stack stack) error {
-	if uint64(addr) >= stack.lo && uint64(addr) < stack.hi {
+	if addr >= stack.lo && addr < stack.hi {
 		return fmt.Errorf("stack object passed to escaping pointer: %s", name)
 	}
 	return nil
diff --git a/pkg/proc/gdbserial/gdbserver.go b/pkg/proc/gdbserial/gdbserver.go
@@ -780,7 +780,7 @@ func (p *gdbProcess) Recorded() (bool, string) {
 
 // Pid returns the process ID.
 func (p *gdbProcess) Pid() int {
-	return int(p.conn.pid)
+	return p.conn.pid
 }
 
 // Valid returns true if we are not detached
diff --git a/pkg/proc/gdbserial/gdbserver_conn.go b/pkg/proc/gdbserial/gdbserver_conn.go
@@ -892,7 +892,7 @@ func (conn *gdbConn) queryProcessInfo(pid int) (map[string]string, error) {
 		case "name":
 			name := make([]byte, len(value)/2)
 			for i := 0; i < len(value); i += 2 {
-				n, _ := strconv.ParseUint(string(value[i:i+2]), 16, 8)
+				n, _ := strconv.ParseUint(value[i:i+2], 16, 8)
 				name[i/2] = byte(n)
 			}
 			pi[key] = string(name)
diff --git a/pkg/proc/mem.go b/pkg/proc/mem.go
@@ -127,7 +127,7 @@ func newCompositeMemory(mem MemoryReadWriter, arch *Arch, regs op.DwarfRegisters
 			cmem.data = append(cmem.data, reg[:piece.Size]...)
 		case op.AddrPiece:
 			buf := make([]byte, piece.Size)
-			mem.ReadMemory(buf, uint64(piece.Val))
+			mem.ReadMemory(buf, piece.Val)
 			cmem.data = append(cmem.data, buf...)
 		case op.ImmPiece:
 			buf := piece.Bytes
@@ -191,7 +191,7 @@ func (mem *compositeMemory) WriteMemory(addr uint64, data []byte) (int, error) {
 					return donesz, err
 				}
 			case op.AddrPiece:
-				n, err := mem.realmem.WriteMemory(uint64(piece.Val), pieceMem)
+				n, err := mem.realmem.WriteMemory(piece.Val, pieceMem)
 				if err != nil {
 					return donesz + n, err
 				}
diff --git a/pkg/proc/proc_general_test.go b/pkg/proc/proc_general_test.go
@@ -44,7 +44,7 @@ type memRead struct {
 
 func (dm *dummyMem) ReadMemory(buf []byte, addr uint64) (int, error) {
 	dm.t.Logf("read addr=%#x size=%#x\n", addr, len(buf))
-	dm.reads = append(dm.reads, memRead{uint64(addr), len(buf)})
+	dm.reads = append(dm.reads, memRead{addr, len(buf)})
 	a := int64(addr) - int64(dm.base)
 	if a < 0 {
 		panic("reading below base")
diff --git a/pkg/proc/stack.go b/pkg/proc/stack.go
diff --git a/pkg/proc/target_exec.go b/pkg/proc/target_exec.go
diff --git a/pkg/proc/types.go b/pkg/proc/types.go
diff --git a/pkg/proc/variables.go b/pkg/proc/variables.go
diff --git a/pkg/proc/winutil/regs_amd64_arch.go b/pkg/proc/winutil/regs_amd64_arch.go
diff --git a/pkg/terminal/starbind/conv.go b/pkg/terminal/starbind/conv.go
diff --git a/service/dap/server_test.go b/service/dap/server_test.go
diff --git a/service/test/integration2_test.go b/service/test/integration2_test.go

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ func DecodeSigned(buf Reader) (int64, uint32) {`
`67`	`67`	`}`
`68`	`68`	`length++`
`69`	`69`
`70`		`- result \|= int64((int64(b) & 0x7f) << shift)`
	`70`	`+ result \|= (int64(b) & 0x7f) << shift`
`71`	`71`	`shift += 7`
`72`	`72`	`if b&0x80 == 0 {`
`73`	`73`	`break`
Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ func (sm *StateMachine) next() error {`
`423`	`423`
`424`	`424`	`func execSpecialOpcode(sm *StateMachine, instr byte) {`
`425`	`425`	`var (`
`426`		`- opcode = uint8(instr)`
	`426`	`+ opcode = instr`
`427`	`427`	`decoded = opcode - sm.dbl.Prologue.OpcodeBase`
`428`	`428`	`)`
`429`	`429`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ func (rdr *Dwarf2Reader) oneAddr() uint64 {`
`87`	`87`	`}`
`88`	`88`	`return uint64(addr)`
`89`	`89`	`case 8:`
`90`		`- addr := uint64(binary.LittleEndian.Uint64(rdr.read(rdr.ptrSz)))`
	`90`	`+ addr := binary.LittleEndian.Uint64(rdr.read(rdr.ptrSz))`
`91`	`91`	`return addr`
`92`	`92`	`default:`
`93`	`93`	`panic("bad address size")`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ func callframecfa(opcode Opcode, ctxt *context) error {`
`208`	`208`	`if ctxt.CFA == 0 {`
`209`	`209`	`return errors.New("could not retrieve CFA for current PC")`
`210`	`210`	`}`
`211`		`- ctxt.stack = append(ctxt.stack, int64(ctxt.CFA))`
	`211`	`+ ctxt.stack = append(ctxt.stack, ctxt.CFA)`
`212`	`212`	`return nil`
`213`	`213`	`}`
`214`	`214`
`@@ -373,7 +373,7 @@ func pick(opcode Opcode, ctxt *context) error {`
`373`	`373`	`default:`
`374`	`374`	`panic("internal error")`
`375`	`375`	`}`
`376`		`- idx := len(ctxt.stack) - 1 - int(uint8(n))`
	`376`	`+ idx := len(ctxt.stack) - 1 - int(n)`
`377`	`377`	`if idx < 0 \|\| idx >= len(ctxt.stack) {`
`378`	`378`	`return ErrStackIndexOutOfBounds`
`379`	`379`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ func New(w WriteCloserSeeker, fhdr elf.FileHeader) Writer {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// e_ident`
`61`		`- r.Write([]byte{0x7f, 'E', 'L', 'F', byte(fhdr.Class), byte(fhdr.Data), byte(fhdr.Version), byte(fhdr.OSABI), byte(fhdr.ABIVersion), 0, 0, 0, 0, 0, 0, 0})`
	`61`	`+ r.Write([]byte{0x7f, 'E', 'L', 'F', byte(fhdr.Class), byte(fhdr.Data), byte(fhdr.Version), byte(fhdr.OSABI), fhdr.ABIVersion, 0, 0, 0, 0, 0, 0, 0})`
`62`	`62`
`63`	`63`	`r.u16(uint16(fhdr.Type)) // e_type`
`64`	`64`	`r.u16(uint16(fhdr.Machine)) // e_machine`