PenaDevops/delve
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pkg,service: remove unnecessary convertions (#3564)

Browse Source
This commit is contained in:
Oleksandr Redko 2023-11-14 17:36:55 +02:00 committed by GitHub
parent e6fdc1052a
commit 938cb6e9d8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 95 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/dwarf/dwarfbuilder/info.go
View File

@ -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)
}

2
pkg/dwarf/leb128/decode.go
View File

@ -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

10
pkg/dwarf/line/line_parser.go
View File

@ -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)

2
pkg/dwarf/line/state_machine.go
View File

@ -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
)

2
pkg/dwarf/loclist/dwarf2_loclist.go
View File

@ -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")

4
pkg/dwarf/op/op.go
View File

@ -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
}

2
pkg/elfwriter/writer.go
View File

@ -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

2
pkg/locspec/locations.go
View File

@ -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

6
pkg/proc/amd64_arch.go
View File

@ -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

22
pkg/proc/arm64_arch.go
View File

@ -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
}

2
pkg/proc/arm64_disasm.go
View File

@ -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
}

2
pkg/proc/bininfo.go
View File

@ -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)
}

2
pkg/proc/breakpoints.go
View File

@ -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 {

2
pkg/proc/core/core.go
View File

@ -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.

4
pkg/proc/core/minidump/minidump.go
View File

@ -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
}

2
pkg/proc/disasm.go
View File

@ -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

10
pkg/proc/dwarf_expr_test.go
View File

@ -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))

8
pkg/proc/eval.go
View File

@ -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 {

8
pkg/proc/fncall.go
View File

@ -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

2
pkg/proc/gdbserial/gdbserver.go
View File

@ -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

2
pkg/proc/gdbserial/gdbserver_conn.go
View File

@ -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)

4
pkg/proc/mem.go
View File

@ -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
}

2
pkg/proc/proc_general_test.go
View File

@ -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")

2
pkg/proc/stack.go
View File

@ -251,7 +251,7 @@ func (it *stackIterator) Next() bool {
it.regs = *regs
it.top = false
if it.g != nil && it.g.ID != 0 {
it.systemstack = !(uint64(it.regs.SP()) >= it.g.stack.lo && uint64(it.regs.SP()) < it.g.stack.hi)
it.systemstack = !(it.regs.SP() >= it.g.stack.lo && it.regs.SP() < it.g.stack.hi)
}
logflags.StackLogger().Debugf("sigtramp context read")
return true

4
pkg/proc/target_exec.go
View File

@ -470,7 +470,7 @@ func sameGoroutineCondition(bi *BinaryInfo, g *G, threadID int) ast.Expr {
}
return astutil.Eql(astutil.PkgVar("runtime", "threadid"), astutil.Int(int64(threadID)))
}
return astutil.Eql(astutil.Sel(astutil.PkgVar("runtime", "curg"), "goid"), astutil.Int(int64(g.ID)))
return astutil.Eql(astutil.Sel(astutil.PkgVar("runtime", "curg"), "goid"), astutil.Int(g.ID))
}
func frameoffCondition(frame *Stackframe) ast.Expr {
@ -1316,7 +1316,7 @@ func (t *Target) handleHardcodedBreakpoints(grp *TargetGroup, trapthread Thread,
return
}
if bpsize := isHardcodedBreakpoint(thread, pc); bpsize > 0 {
setPC(thread, pc+uint64(bpsize))
setPC(thread, pc+bpsize)
}
}

4
pkg/proc/types.go
View File

@ -114,7 +114,7 @@ func runtimeTypeToDIE(_type *Variable, dataAddr uint64) (typ godwarf.Type, kind
if md != nil {
so := bi.moduleDataToImage(md)
if so != nil {
if rtdie, ok := so.runtimeTypeToDIE[uint64(_type.Addr-md.types)]; ok {
if rtdie, ok := so.runtimeTypeToDIE[_type.Addr-md.types]; ok {
typ, err := godwarf.ReadType(so.dwarf, so.index, rtdie.offset, so.typeCache)
if err != nil {
return nil, 0, fmt.Errorf("invalid interface type: %v", err)
@ -189,7 +189,7 @@ func dwarfToRuntimeType(bi *BinaryInfo, mem MemoryReadWriter, typ godwarf.Type)
}
}
typeAddr = uint64(md.types) + off
typeAddr = md.types + off
rtyp, err := bi.findType(bi.runtimeTypeTypename())
if err != nil {

24
pkg/proc/variables.go
View File

@ -959,7 +959,7 @@ func (v *Variable) parseG() (*G, error) {
SP: uint64(sp),
BP: uint64(bp),
LR: uint64(lr),
Status: uint64(status),
Status: status,
WaitSince: waitSince,
WaitReason: waitReason,
CurrentLoc: Location{PC: uint64(pc), File: f, Line: l, Fn: fn},
@ -1454,7 +1454,7 @@ func convertToEface(srcv, dstv *Variable) error {
return srcv.Unreadable
}
_type = _type.maybeDereference()
dstv.writeEmptyInterface(uint64(_type.Addr), data)
dstv.writeEmptyInterface(_type.Addr, data)
return nil
}
typeAddr, typeKind, runtimeTypeFound, err := dwarfToRuntimeType(srcv.bi, srcv.mem, srcv.RealType)
@ -1738,13 +1738,13 @@ func (v *Variable) readComplex(size int64) {
}
func (v *Variable) writeComplex(real, imag float64, size int64) error {
err := v.writeFloatRaw(real, int64(size/2))
err := v.writeFloatRaw(real, size/2)
if err != nil {
return err
}
imagaddr := *v
imagaddr.Addr += uint64(size / 2)
return imagaddr.writeFloatRaw(imag, int64(size/2))
return imagaddr.writeFloatRaw(imag, size/2)
}
func readIntRaw(mem MemoryReadWriter, addr uint64, size int64) (int64, error) {
@ -1781,7 +1781,7 @@ func (v *Variable) writeUint(value uint64, size int64) error {
case 4:
binary.LittleEndian.PutUint32(val, uint32(value))
case 8:
binary.LittleEndian.PutUint64(val, uint64(value))
binary.LittleEndian.PutUint64(val, value)
}
_, err := v.mem.WriteMemory(v.Addr, val)
@ -1805,7 +1805,7 @@ func readUintRaw(mem MemoryReadWriter, addr uint64, size int64) (uint64, error)
case 4:
n = uint64(binary.LittleEndian.Uint32(val))
case 8:
n = uint64(binary.LittleEndian.Uint64(val))
n = binary.LittleEndian.Uint64(val)
}
return n, nil
@ -1841,7 +1841,7 @@ func (v *Variable) writeFloatRaw(f float64, size int64) error {
n := float32(f)
binary.Write(buf, binary.LittleEndian, n)
case 8:
n := float64(f)
n := f
binary.Write(buf, binary.LittleEndian, n)
}
@ -1878,7 +1878,7 @@ func (v *Variable) writeSlice(len, cap int64, base uint64) error {
switch f.Name {
case sliceArrayFieldName:
arrv, _ := v.toField(f)
if err := arrv.writeUint(uint64(base), arrv.RealType.Size()); err != nil {
if err := arrv.writeUint(base, arrv.RealType.Size()); err != nil {
return err
}
case sliceLenFieldName:
@ -1897,8 +1897,8 @@ func (v *Variable) writeSlice(len, cap int64, base uint64) error {
}
func (v *Variable) writeString(len, base uint64) error {
writePointer(v.bi, v.mem, uint64(v.Addr), base)
writePointer(v.bi, v.mem, uint64(v.Addr)+uint64(v.bi.Arch.PtrSize()), len)
writePointer(v.bi, v.mem, v.Addr, base)
writePointer(v.bi, v.mem, v.Addr+uint64(v.bi.Arch.PtrSize()), len)
return nil
}
@ -1931,7 +1931,7 @@ func (v *Variable) readFunctionPtr() {
}
v.Base = val
fn := v.bi.PCToFunc(uint64(v.Base))
fn := v.bi.PCToFunc(v.Base)
if fn == nil {
v.Unreadable = fmt.Errorf("could not find function for %#v", v.Base)
return
@ -2406,7 +2406,7 @@ func (v *Variable) registerVariableTypeConv(newtyp string) (*Variable, error) {
child.Kind = reflect.Uint32
n = 4
case "uint64":
child = newConstant(constant.MakeUint64(uint64(binary.LittleEndian.Uint64(v.reg.Bytes[i:]))), v.mem)
child = newConstant(constant.MakeUint64(binary.LittleEndian.Uint64(v.reg.Bytes[i:])), v.mem)
child.Kind = reflect.Uint64
n = 8
case "float32":

34
pkg/proc/winutil/regs_amd64_arch.go
View File

@ -43,23 +43,23 @@ type AMD64Registers struct {
// struct and the TEB base address of the thread.
func NewAMD64Registers(context *AMD64CONTEXT, TebBaseAddress uint64) *AMD64Registers {
regs := &AMD64Registers{
rax: uint64(context.Rax),
rbx: uint64(context.Rbx),
rcx: uint64(context.Rcx),
rdx: uint64(context.Rdx),
rdi: uint64(context.Rdi),
rsi: uint64(context.Rsi),
rbp: uint64(context.Rbp),
rsp: uint64(context.Rsp),
r8: uint64(context.R8),
r9: uint64(context.R9),
r10: uint64(context.R10),
r11: uint64(context.R11),
r12: uint64(context.R12),
r13: uint64(context.R13),
r14: uint64(context.R14),
r15: uint64(context.R15),
rip: uint64(context.Rip),
rax: context.Rax,
rbx: context.Rbx,
rcx: context.Rcx,
rdx: context.Rdx,
rdi: context.Rdi,
rsi: context.Rsi,
rbp: context.Rbp,
rsp: context.Rsp,
r8: context.R8,
r9: context.R9,
r10: context.R10,
r11: context.R11,
r12: context.R12,
r13: context.R13,
r14: context.R14,
r15: context.R15,
rip: context.Rip,
eflags: uint64(context.EFlags),
cs: uint64(context.SegCs),
fs: uint64(context.SegFs),

2
pkg/terminal/starbind/conv.go
View File

@ -20,7 +20,7 @@ var autoLoadConfig = api.LoadConfig{MaxVariableRecurse: 1, MaxStringLen: 1024, M
func (env *Env) interfaceToStarlarkValue(v interface{}) starlark.Value {
switch v := v.(type) {
case bool:
return starlark.Bool(bool(v))
return starlark.Bool(v)
case uint8:
return starlark.MakeUint64(uint64(v))
case uint16:

6
service/dap/server_test.go
View File

@ -7353,7 +7353,7 @@ func TestFindInstructions(t *testing.T) {
{
name: "request out of bounds",
args: args{
addr: uint64(uint64(startPC + 2*(numInstructions-1))),
addr: uint64(startPC + 2*(numInstructions-1)),
offset: 1,
count: numInstructions,
},
@ -7512,11 +7512,11 @@ func TestRedirect(t *testing.T) {
// check output
if expectStdout != stdout.String() {
t.Errorf("\n got stdout: len:%d\n%s\nwant: len:%d\n%s", stdout.Len(), stdout.String(), len(expectStdout), string(expectStdout))
t.Errorf("\n got stdout: len:%d\n%s\nwant: len:%d\n%s", stdout.Len(), stdout.String(), len(expectStdout), expectStdout)
}
if expectStderr != stderr.String() {
t.Errorf("\n got stderr: len:%d \n%s\nwant: len:%d\n%s", stderr.Len(), stderr.String(), len(expectStderr), string(expectStderr))
t.Errorf("\n got stderr: len:%d \n%s\nwant: len:%d\n%s", stderr.Len(), stderr.String(), len(expectStderr), expectStderr)
}
// 7 >> disconnect, << disconnect

8
service/test/integration2_test.go
View File

@ -1543,7 +1543,7 @@ func TestSkipPrologue(t *testing.T) {
findLocationHelper(t, c, "*fn1", false, 1, afunction)
findLocationHelper(t, c, "locationsprog2.go:8", false, 1, afunction)
afunction0 := uint64(clientEvalVariable(t, c, "main.afunction").Addr)
afunction0 := clientEvalVariable(t, c, "main.afunction").Addr
if afunction == afunction0 {
t.Fatal("Skip prologue failed")
@ -1554,21 +1554,21 @@ func TestSkipPrologue(t *testing.T) {
func TestSkipPrologue2(t *testing.T) {
withTestClient2("callme", t, func(c service.Client) {
callme := findLocationHelper(t, c, "main.callme", false, 1, 0)[0]
callmeZ := uint64(clientEvalVariable(t, c, "main.callme").Addr)
callmeZ := clientEvalVariable(t, c, "main.callme").Addr
findLocationHelper(t, c, "callme.go:5", false, 1, callme)
if callme == callmeZ {
t.Fatal("Skip prologue failed")
}
callme2 := findLocationHelper(t, c, "main.callme2", false, 1, 0)[0]
callme2Z := uint64(clientEvalVariable(t, c, "main.callme2").Addr)
callme2Z := clientEvalVariable(t, c, "main.callme2").Addr
findLocationHelper(t, c, "callme.go:12", false, 1, callme2)
if callme2 == callme2Z {
t.Fatal("Skip prologue failed")
}
callme3 := findLocationHelper(t, c, "main.callme3", false, 1, 0)[0]
callme3Z := uint64(clientEvalVariable(t, c, "main.callme3").Addr)
callme3Z := clientEvalVariable(t, c, "main.callme3").Addr
ver, _ := goversion.Parse(runtime.Version())
if (ver.Major < 0 || ver.AfterOrEqual(goversion.GoVer18Beta)) && runtime.GOARCH != "386" {