blob: 6a6493a4130b901152c65c2b291cd186693101b3 [file] [log] [blame]
// Copyright 2018 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Evaluates Go expressions, using the current values of variables in a program
// being debugged.
//
// TODOs:
// More overflow checking.
// Stricter type checking.
// More expression types.
// +build linux
package server
import (
"errors"
"fmt"
"go/ast"
"go/parser"
"go/token"
"math"
"math/big"
"cloud.google.com/go/cmd/go-cloud-debug-agent/internal/debug"
"cloud.google.com/go/cmd/go-cloud-debug-agent/internal/debug/dwarf"
)
const prec = 256 // precision for untyped float and complex constants.
var (
// Some big.Ints to use in overflow checks.
bigIntMaxInt32 = big.NewInt(math.MaxInt32)
bigIntMinInt32 = big.NewInt(math.MinInt32)
bigIntMaxInt64 = big.NewInt(math.MaxInt64)
bigIntMinInt64 = big.NewInt(math.MinInt64)
bigIntMaxUint64 = new(big.Int).SetUint64(math.MaxUint64)
)
// result stores an intermediate value produced during evaluation of an expression.
//
// d contains the DWARF type of the value. For untyped values, d will be nil.
//
// v contains the value itself. For numeric and bool types, v will have the
// corresponding predeclared Go type.
// For untyped integer, rune, float, complex, string, and bool constants, v will
// have type untInt, untRune, untFloat, untComplex, untString, or bool,
// respectively.
// For values of type int, uint and uintptr, v will be an int32, int64, uint32
// or uint64 as appropriate.
// For address operations, v will have type pointerToValue.
// For the operands of address operations, v will have type addressableValue.
// Other types are represented using the corresponding implementation of
// debug.Value in program.go.
//
// If an evaluation results in an error, the zero value of result is used.
type result struct {
d dwarf.Type
v interface{}
}
// untInt is an untyped integer constant
type untInt struct {
*big.Int
}
// untRune is an untyped rune constant
type untRune struct {
*big.Int
}
// untFloat is an untyped floating-point constant
type untFloat struct {
*big.Float
}
// untComplex is an untyped complex constant
type untComplex struct {
r *big.Float
i *big.Float
}
// untString is an untyped string constant
type untString string
// pointerToValue is a pointer to a value in memory.
// The evaluator constructs these as the result of address operations like "&x".
// Unlike debug.Pointer, the DWARF type stored alongside values of this type
// is the type of the variable, not the type of the pointer.
type pointerToValue struct {
a uint64
}
// addressableValue is the memory location of a value.
// The evaluator constructs these while evaluating the operands of address
// operations like "&x", instead of computing the value of x itself.
type addressableValue struct {
a uint64
}
// A sliceOf is a slice created by slicing an array.
// Unlike debug.Slice, the DWARF type stored alongside a value of this type is
// the type of the slice's elements, not the type of the slice.
type sliceOf debug.Slice
// ident is a value for representing a special identifier.
type ident string
// identLookup is a built-in function of the expression evaluator which gets the
// value of a global symbol.
var identLookup ident = "lookup"
// evalExpression evaluates a Go expression.
// If the program counter and stack pointer are nonzero, they are used to determine
// what local variables are available and where in memory they are.
func (s *Server) evalExpression(expression string, pc, sp uint64) (debug.Value, error) {
e := evaluator{server: s, expression: expression, pc: pc, sp: sp}
node, err := parser.ParseExpr(expression)
if err != nil {
return nil, err
}
val := e.evalNode(node, false)
if e.evalError != nil {
return nil, e.evalError
}
// Convert untyped constants to their default types.
switch v := val.v.(type) {
case untInt:
return e.intFromInteger(v)
case untRune:
if v.Cmp(bigIntMaxInt32) == +1 {
return nil, errors.New("constant overflows rune")
}
if v.Cmp(bigIntMinInt32) == -1 {
return nil, errors.New("constant overflows rune")
}
return int32(v.Int64()), nil
case untFloat:
f, _ := v.Float64()
if math.IsInf(f, 0) {
return nil, errors.New("constant overflows float64")
}
if math.IsNaN(f) {
return nil, errors.New("constant is NaN")
}
return f, nil
case untComplex:
r, _ := v.r.Float64()
i, _ := v.i.Float64()
if math.IsInf(r, 0) || math.IsInf(i, 0) {
return nil, errors.New("constant overflows complex128")
}
if math.IsNaN(r) || math.IsNaN(i) {
return nil, errors.New("constant is NaN")
}
return complex(r, i), nil
case untString:
return debug.String{Length: uint64(len(v)), String: string(v)}, nil
case pointerToValue:
return debug.Pointer{TypeID: uint64(val.d.Common().Offset), Address: v.a}, nil
case sliceOf:
return debug.Slice(v), nil
case nil, addressableValue:
// This case should not be reachable.
return nil, errors.New("unknown error")
}
return val.v, nil
}
type evaluator struct {
// expression is the expression being evaluated.
expression string
// server interacts with the program being debugged.
server *Server
// curNode is the current parse tree node. This is set so that error messages
// can quote the part of the expression that caused an error.
curNode ast.Node
// evalError is the first error that occurred while evaluating the expression,
// or nil if no error has occurred.
evalError error
// pc and sp are the current program counter and stack pointer, used for
// finding local variables. If either are zero, the expression is evaluated
// without using local variables.
pc uint64
sp uint64
}
// setNode sets curNode, and returns curNode's previous value.
func (e *evaluator) setNode(node ast.Node) (old ast.Node) {
old, e.curNode = e.curNode, node
return old
}
// err saves an error that occurred during evaluation.
// It returns a zero result, so that functions can exit and set an error with
// return e.err(...)
func (e *evaluator) err(s string) result {
if e.evalError != nil {
return result{}
}
// Append the substring of the expression that corresponds to the current AST node.
start := int(e.curNode.Pos() - 1)
end := int(e.curNode.End() - 1)
if start < 0 {
start = 0
}
if end > len(e.expression) {
end = len(e.expression)
}
if start > end {
start, end = 0, 0
}
e.evalError = errors.New(s + `: "` + e.expression[start:end] + `"`)
return result{}
}
// evalNode computes the value of a node in the expression tree.
// If getAddress is true, the node is the argument of an & operator, so evalNode
// will return a result with a value of type addressableValue if possible.
func (e *evaluator) evalNode(node ast.Node, getAddress bool) result {
// Set the current node in the evaluator, so that error messages can refer to
// it. Defer a function call that changes it back.
defer e.setNode(e.setNode(node))
switch n := node.(type) {
case *ast.Ident:
if e.pc != 0 && e.sp != 0 {
a, t := e.server.findLocalVar(n.Name, e.pc, e.sp)
if t != nil {
return e.resultFrom(a, t, getAddress)
}
}
a, t := e.server.findGlobalVar(n.Name)
if t != nil {
return e.resultFrom(a, t, getAddress)
}
switch n.Name {
// Note: these could have been redefined as constants in the code, but we
// don't have a way to detect that.
case "true":
return result{nil, true}
case "false":
return result{nil, false}
case "lookup":
return result{nil, identLookup}
}
return e.err("unknown identifier")
case *ast.BasicLit:
switch n.Kind {
case token.INT:
i := new(big.Int)
if _, ok := i.SetString(n.Value, 0); !ok {
return e.err("invalid integer constant")
}
return result{nil, untInt{i}}
case token.FLOAT:
r, _, err := big.ParseFloat(n.Value, 10, prec, big.ToNearestEven)
if err != nil {
return e.err(err.Error())
}
return result{nil, untFloat{r}}
case token.IMAG:
if len(n.Value) <= 1 || n.Value[len(n.Value)-1] != 'i' {
return e.err("invalid imaginary constant")
}
r, _, err := big.ParseFloat(n.Value[:len(n.Value)-1], 10, prec, big.ToNearestEven)
if err != nil {
return e.err(err.Error())
}
return result{nil, untComplex{new(big.Float), r}}
case token.CHAR:
// TODO: unescaping
return result{nil, untRune{new(big.Int).SetInt64(int64(n.Value[1]))}}
case token.STRING:
// TODO: unescaping
if len(n.Value) <= 1 {
return e.err("invalid string constant")
}
return result{nil, untString(n.Value[1 : len(n.Value)-1])}
}
case *ast.ParenExpr:
return e.evalNode(n.X, getAddress)
case *ast.StarExpr:
x := e.evalNode(n.X, false)
switch v := x.v.(type) {
case debug.Pointer:
// x.d may be a typedef pointing to a pointer type (or a typedef pointing
// to a typedef pointing to a pointer type, etc.), so remove typedefs
// until we get the underlying pointer type.
t := followTypedefs(x.d)
if pt, ok := t.(*dwarf.PtrType); ok {
return e.resultFrom(v.Address, pt.Type, getAddress)
} else {
return e.err("invalid DWARF type for pointer")
}
case pointerToValue:
return e.resultFrom(v.a, x.d, getAddress)
case nil:
return x
}
return e.err("invalid indirect")
case *ast.SelectorExpr:
x := e.evalNode(n.X, false)
sel := n.Sel.Name
switch v := x.v.(type) {
case debug.Struct:
for _, f := range v.Fields {
if f.Name == sel {
t, err := e.server.dwarfData.Type(dwarf.Offset(f.Var.TypeID))
if err != nil {
return e.err(err.Error())
}
return e.resultFrom(f.Var.Address, t, getAddress)
}
}
return e.err("struct field not found")
case debug.Pointer:
pt, ok := followTypedefs(x.d).(*dwarf.PtrType) // x.d should be a pointer to struct.
if !ok {
return e.err("invalid DWARF information for pointer")
}
st, ok := followTypedefs(pt.Type).(*dwarf.StructType)
if !ok {
break
}
for _, f := range st.Field {
if f.Name == sel {
return e.resultFrom(v.Address+uint64(f.ByteOffset), f.Type, getAddress)
}
}
return e.err("struct field not found")
case pointerToValue:
st, ok := followTypedefs(x.d).(*dwarf.StructType) // x.d should be a struct.
if !ok {
break
}
for _, f := range st.Field {
if f.Name == sel {
return e.resultFrom(v.a+uint64(f.ByteOffset), f.Type, getAddress)
}
}
return e.err("struct field not found")
}
return e.err("invalid selector expression")
case *ast.IndexExpr:
x, index := e.evalNode(n.X, false), e.evalNode(n.Index, false)
if x.v == nil || index.v == nil {
return result{}
}
// The expression is x[index]
if m, ok := x.v.(debug.Map); ok {
if getAddress {
return e.err("can't take address of map value")
}
mt, ok := followTypedefs(x.d).(*dwarf.MapType)
if !ok {
return e.err("invalid DWARF type for map")
}
var (
found bool // true if the key was found
value result // the map value for the key
abort bool // true if an error occurred while searching
// fn is a function that checks if one (key, value) pair corresponds
// to the index in the expression.
fn = func(keyAddr, valAddr uint64, keyType, valType dwarf.Type) bool {
key := e.resultFrom(keyAddr, keyType, false)
if key.v == nil {
abort = true
return false // stop searching map
}
equal, ok := e.evalBinaryOp(token.EQL, index, key).v.(bool)
if !ok {
abort = true
return false // stop searching map
}
if equal {
found = true
value = e.resultFrom(valAddr, valType, false)
return false // stop searching map
}
return true // continue searching map
}
)
if err := e.server.peekMapValues(mt, m.Address, fn); err != nil {
return e.err(err.Error())
}
if abort {
// Some operation on individual map keys failed.
return result{}
}
if found {
return value
}
// The key wasn't in the map; return the zero value.
return e.zero(mt.ElemType)
}
// The index should be a non-negative integer for the remaining cases.
u, err := uint64FromResult(index)
if err != nil {
return e.err("invalid index: " + err.Error())
}
switch v := x.v.(type) {
case debug.Array:
if u >= v.Length {
return e.err("array index out of bounds")
}
elemType, err := e.server.dwarfData.Type(dwarf.Offset(v.ElementTypeID))
if err != nil {
return e.err(err.Error())
}
return e.resultFrom(v.Element(u).Address, elemType, getAddress)
case debug.Slice:
if u >= v.Length {
return e.err("slice index out of bounds")
}
elemType, err := e.server.dwarfData.Type(dwarf.Offset(v.ElementTypeID))
if err != nil {
return e.err(err.Error())
}
return e.resultFrom(v.Element(u).Address, elemType, getAddress)
case sliceOf:
if u >= v.Length {
return e.err("slice index out of bounds")
}
return e.resultFrom(v.Element(u).Address, x.d, getAddress)
case debug.String:
if getAddress {
return e.err("can't take address of string element")
}
if u >= v.Length {
return e.err("string index out of bounds")
}
if u >= uint64(len(v.String)) {
return e.err("string element unavailable")
}
return e.uint8Result(v.String[u])
case untString:
if getAddress {
return e.err("can't take address of string element")
}
if u >= uint64(len(v)) {
return e.err("string index out of bounds")
}
return e.uint8Result(v[u])
}
return e.err("invalid index expression")
case *ast.SliceExpr:
if n.Slice3 && n.High == nil {
return e.err("middle index required in full slice")
}
if n.Slice3 && n.Max == nil {
return e.err("final index required in full slice")
}
var (
low, high, max uint64
err error
)
if n.Low != nil {
low, err = uint64FromResult(e.evalNode(n.Low, false))
if err != nil {
return e.err("invalid slice lower bound: " + err.Error())
}
}
if n.High != nil {
high, err = uint64FromResult(e.evalNode(n.High, false))
if err != nil {
return e.err("invalid slice upper bound: " + err.Error())
}
}
if n.Max != nil {
max, err = uint64FromResult(e.evalNode(n.Max, false))
if err != nil {
return e.err("invalid slice capacity: " + err.Error())
}
}
x := e.evalNode(n.X, false)
switch v := x.v.(type) {
case debug.Array, debug.Pointer, pointerToValue:
// This case handles the slicing of arrays and pointers to arrays.
var arr debug.Array
switch v := x.v.(type) {
case debug.Array:
arr = v
case debug.Pointer:
pt, ok := followTypedefs(x.d).(*dwarf.PtrType)
if !ok {
return e.err("invalid DWARF type for pointer")
}
a := e.resultFrom(v.Address, pt.Type, false)
arr, ok = a.v.(debug.Array)
if !ok {
// v is a pointer to something other than an array.
return e.err("cannot slice pointer")
}
case pointerToValue:
a := e.resultFrom(v.a, x.d, false)
var ok bool
arr, ok = a.v.(debug.Array)
if !ok {
// v is a pointer to something other than an array.
return e.err("cannot slice pointer")
}
}
elemType, err := e.server.dwarfData.Type(dwarf.Offset(arr.ElementTypeID))
if err != nil {
return e.err(err.Error())
}
if n.High == nil {
high = arr.Length
} else if high > arr.Length {
return e.err("slice upper bound is too large")
}
if n.Max == nil {
max = arr.Length
} else if max > arr.Length {
return e.err("slice capacity is too large")
}
if low > high || high > max {
return e.err("invalid slice index")
}
return result{
d: elemType,
v: sliceOf{
Array: debug.Array{
ElementTypeID: arr.ElementTypeID,
Address: arr.Element(low).Address,
Length: high - low,
StrideBits: uint64(elemType.Common().ByteSize) * 8,
},
Capacity: max - low,
},
}
case debug.Slice:
if n.High == nil {
high = v.Length
} else if high > v.Capacity {
return e.err("slice upper bound is too large")
}
if n.Max == nil {
max = v.Capacity
} else if max > v.Capacity {
return e.err("slice capacity is too large")
}
if low > high || high > max {
return e.err("invalid slice index")
}
v.Address += low * (v.StrideBits / 8)
v.Length = high - low
v.Capacity = max - low
return result{x.d, v}
case sliceOf:
if n.High == nil {
high = v.Length
} else if high > v.Capacity {
return e.err("slice upper bound is too large")
}
if n.Max == nil {
max = v.Capacity
} else if max > v.Capacity {
return e.err("slice capacity is too large")
}
if low > high || high > max {
return e.err("invalid slice index")
}
v.Address += low * (v.StrideBits / 8)
v.Length = high - low
v.Capacity = max - low
return result{x.d, v}
case debug.String:
if n.Max != nil {
return e.err("full slice of string")
}
if n.High == nil {
high = v.Length
}
if low > high || high > v.Length {
return e.err("invalid slice index")
}
v.Length = high - low
if low > uint64(len(v.String)) {
// v.String was truncated before the point where this slice starts.
v.String = ""
} else {
if high > uint64(len(v.String)) {
// v.String was truncated before the point where this slice ends.
high = uint64(len(v.String))
}
v.String = v.String[low:high]
}
return result{x.d, v}
case untString:
if n.Max != nil {
return e.err("full slice of string")
}
if n.High == nil {
high = uint64(len(v))
}
if low > high {
return e.err("invalid slice expression")
}
if high > uint64(len(v)) {
return e.err("slice upper bound is too large")
}
return e.stringResult(string(v[low:high]))
default:
return e.err("invalid slice expression")
}
case *ast.CallExpr:
// Only supports lookup("x"), which gets the value of a global symbol x.
fun := e.evalNode(n.Fun, false)
var args []result
for _, a := range n.Args {
args = append(args, e.evalNode(a, false))
}
if fun.v == identLookup {
if len(args) != 1 {
return e.err("lookup should have one argument")
}
ident, ok := args[0].v.(untString)
if !ok {
return e.err("argument for lookup should be a string constant")
}
if a, t := e.server.findGlobalVar(string(ident)); t == nil {
return e.err("symbol not found")
} else {
return e.resultFrom(a, t, getAddress)
}
}
return e.err("function calls not implemented")
case *ast.UnaryExpr:
if n.Op == token.AND {
x := e.evalNode(n.X, true)
switch v := x.v.(type) {
case addressableValue:
return result{x.d, pointerToValue{v.a}}
case nil:
return x
}
return e.err("can't take address")
}
x := e.evalNode(n.X, false)
if x.v == nil {
return x
}
switch v := x.v.(type) {
case int8:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case int16:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case int32:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case int64:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case uint8:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case uint16:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case uint32:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case uint64:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
case token.XOR:
v = ^v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case float32:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case float64:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case complex64:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case complex128:
switch n.Op {
case token.ADD:
case token.SUB:
v = -v
default:
return e.err("invalid operation")
}
return result{x.d, v}
case untInt:
switch n.Op {
case token.ADD:
case token.SUB:
v.Int.Neg(v.Int)
case token.XOR:
v.Int.Not(v.Int)
default:
return e.err("invalid operation")
}
return result{x.d, v}
case untRune:
switch n.Op {
case token.ADD:
case token.SUB:
v.Int.Neg(v.Int)
case token.XOR:
v.Int.Not(v.Int)
default:
return e.err("invalid operation")
}
return result{x.d, v}
case untFloat:
switch n.Op {
case token.ADD:
case token.SUB:
v.Float.Neg(v.Float)
default:
return e.err("invalid operation")
}
return result{x.d, v}
case untComplex:
switch n.Op {
case token.ADD:
case token.SUB:
v.r.Neg(v.r)
v.i.Neg(v.i)
default:
return e.err("invalid operation")
}
return result{x.d, v}
case bool:
switch n.Op {
case token.NOT:
v = !v
default:
return e.err("invalid operation")
}
return result{x.d, v}
}
case *ast.BinaryExpr:
x := e.evalNode(n.X, false)
if x.v == nil {
return x
}
y := e.evalNode(n.Y, false)
if y.v == nil {
return y
}
return e.evalBinaryOp(n.Op, x, y)
}
return e.err("invalid expression")
}
// evalBinaryOp evaluates a binary operator op applied to x and y.
func (e *evaluator) evalBinaryOp(op token.Token, x, y result) result {
if op == token.NEQ {
tmp := e.evalBinaryOp(token.EQL, x, y)
b, ok := tmp.v.(bool)
if !ok {
return tmp
}
return result{nil, !b}
}
if op == token.GTR {
return e.evalBinaryOp(token.LSS, y, x)
}
if op == token.GEQ {
return e.evalBinaryOp(token.LEQ, x, y)
}
x = convertUntyped(x, y)
y = convertUntyped(y, x)
switch a := x.v.(type) {
case int8:
b, ok := y.v.(int8)
if !ok {
return e.err("type mismatch")
}
var c int8
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case int16:
b, ok := y.v.(int16)
if !ok {
return e.err("type mismatch")
}
var c int16
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case int32:
b, ok := y.v.(int32)
if !ok {
return e.err("type mismatch")
}
var c int32
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case int64:
b, ok := y.v.(int64)
if !ok {
return e.err("type mismatch")
}
var c int64
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case uint8:
b, ok := y.v.(uint8)
if !ok {
return e.err("type mismatch")
}
var c uint8
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case uint16:
b, ok := y.v.(uint16)
if !ok {
return e.err("type mismatch")
}
var c uint16
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case uint32:
b, ok := y.v.(uint32)
if !ok {
return e.err("type mismatch")
}
var c uint32
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case uint64:
b, ok := y.v.(uint64)
if !ok {
return e.err("type mismatch")
}
var c uint64
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.OR:
c = a | b
case token.XOR:
c = a ^ b
case token.MUL:
c = a * b
case token.QUO:
if b == 0 {
return e.err("integer divide by zero")
}
c = a / b
case token.REM:
if b == 0 {
return e.err("integer divide by zero")
}
c = a % b
case token.AND:
c = a & b
case token.AND_NOT:
c = a &^ b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case float32:
b, ok := y.v.(float32)
if !ok {
return e.err("type mismatch")
}
var c float32
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.MUL:
c = a * b
case token.QUO:
c = a / b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case float64:
b, ok := y.v.(float64)
if !ok {
return e.err("type mismatch")
}
var c float64
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.MUL:
c = a * b
case token.QUO:
c = a / b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case complex64:
b, ok := y.v.(complex64)
if !ok {
return e.err("type mismatch")
}
var c complex64
switch op {
case token.EQL:
return result{nil, a == b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.MUL:
c = a * b
case token.QUO:
c = a / b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case complex128:
b, ok := y.v.(complex128)
if !ok {
return e.err("type mismatch")
}
var c complex128
switch op {
case token.EQL:
return result{nil, a == b}
case token.ADD:
c = a + b
case token.SUB:
c = a - b
case token.MUL:
c = a * b
case token.QUO:
c = a / b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case bool:
b, ok := y.v.(bool)
if !ok {
return e.err("type mismatch")
}
var c bool
switch op {
case token.LOR:
c = a || b
case token.LAND:
c = a && b
case token.EQL:
c = a == b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case debug.String:
b, ok := y.v.(debug.String)
if !ok {
return e.err("type mismatch")
}
var c debug.String
switch op {
// TODO: these comparison operators only use the part of the string that
// was read. Very large strings do not have their entire contents read by
// server.value.
case token.EQL:
return result{nil, a.Length == b.Length && a.String == b.String}
case token.LSS:
return result{nil, a.String < b.String}
case token.LEQ:
return result{nil, a.String <= b.String}
case token.ADD:
c.Length = a.Length + b.Length
if a.Length == uint64(len(a.String)) {
c.String = a.String + b.String
} else {
// The first string was truncated at a.Length characters, so the sum
// must be truncated there too.
c.String = a.String
}
default:
return e.err("invalid operation")
}
return result{x.d, c}
case untString:
b, ok := y.v.(untString)
if !ok {
return e.err("type mismatch")
}
var c untString
switch op {
case token.EQL:
return result{nil, a == b}
case token.LSS:
return result{nil, a < b}
case token.LEQ:
return result{nil, a <= b}
case token.ADD:
c = a + b
default:
return e.err("invalid operation")
}
return result{x.d, c}
case untInt:
i := a.Int
b, ok := y.v.(untInt)
if !ok {
return e.err("type mismatch")
}
switch op {
case token.EQL:
return result{nil, i.Cmp(b.Int) == 0}
case token.LSS:
return result{nil, i.Cmp(b.Int) < 0}
case token.LEQ:
return result{nil, i.Cmp(b.Int) <= 0}
}
c := new(big.Int)
switch op {
case token.ADD:
c.Add(i, b.Int)
case token.SUB:
c.Sub(i, b.Int)
case token.OR:
c.Or(i, b.Int)
case token.XOR:
c.Xor(i, b.Int)
case token.MUL:
c.Mul(i, b.Int)
case token.QUO:
if b.Sign() == 0 {
return e.err("integer divide by zero")
}
c.Quo(i, b.Int)
case token.REM:
if b.Sign() == 0 {
return e.err("integer divide by zero")
}
c.Mod(i, b.Int)
case token.AND:
c.And(i, b.Int)
case token.AND_NOT:
c.AndNot(i, b.Int)
default:
return e.err("invalid operation")
}
return result{nil, untInt{c}}
case untRune:
i := a.Int
b, ok := y.v.(untRune)
if !ok {
return e.err("type mismatch")
}
switch op {
case token.EQL:
return result{nil, i.Cmp(b.Int) == 0}
case token.LSS:
return result{nil, i.Cmp(b.Int) < 0}
case token.LEQ:
return result{nil, i.Cmp(b.Int) <= 0}
}
c := new(big.Int)
switch op {
case token.ADD:
c.Add(i, b.Int)
case token.SUB:
c.Sub(i, b.Int)
case token.OR:
c.Or(i, b.Int)
case token.XOR:
c.Xor(i, b.Int)
case token.MUL:
c.Mul(i, b.Int)
case token.QUO:
if b.Sign() == 0 {
return e.err("integer divide by zero")
}
c.Quo(i, b.Int)
case token.REM:
if b.Sign() == 0 {
return e.err("integer divide by zero")
}
c.Mod(i, b.Int)
case token.AND:
c.And(i, b.Int)
case token.AND_NOT:
c.AndNot(i, b.Int)
default:
return e.err("invalid operation")
}
return result{nil, untRune{c}}
case untFloat:
r := a.Float
b, ok := y.v.(untFloat)
if !ok {
return e.err("type mismatch")
}
switch op {
case token.EQL:
return result{nil, r.Cmp(b.Float) == 0}
case token.LSS:
return result{nil, r.Cmp(b.Float) < 0}
case token.LEQ:
return result{nil, r.Cmp(b.Float) <= 0}
}
c := new(big.Float)
switch op {
case token.ADD:
c.Add(r, b.Float)
case token.SUB:
c.Sub(r, b.Float)
case token.MUL:
c.Mul(r, b.Float)
case token.QUO:
if b.Sign() == 0 {
return e.err("divide by zero")
}
c.Quo(r, b.Float)
default:
return e.err("invalid operation")
}
return result{nil, untFloat{c}}
case untComplex:
b, ok := y.v.(untComplex)
if !ok {
return e.err("type mismatch")
}
var (
ar = a.r
br = b.r
ai = a.i
bi = b.i
)
if op == token.EQL {
return result{nil, ar.Cmp(br) == 0 && ai.Cmp(bi) == 0}
}
var (
cr = new(big.Float)
ci = new(big.Float)
)
switch op {
case token.ADD:
cr.Add(ar, br)
ci.Add(ai, bi)
case token.SUB:
cr.Sub(ar, br)
ci.Sub(ai, bi)
case token.MUL:
var t0, t1 big.Float
t0.Mul(ar, br)
t1.Mul(ai, bi)
cr.Sub(&t0, &t1)
t0.Mul(ar, bi)
t1.Mul(ai, br)
ci.Add(&t0, &t1)
case token.QUO:
// a/b = a*conj(b)/|b|^2
var t0, t1 big.Float
cr.Mul(ar, br)
t0.Mul(ai, bi)
cr.Add(cr, &t0) // cr = Re(a*conj(b))
ci.Mul(ai, br)
t0.Mul(ar, bi)
ci.Sub(ci, &t0) // ci = Im(a*conj(b))
t0.Mul(br, br)
t1.Mul(bi, bi)
t0.Add(&t0, &t1) // t0 = |b|^2
if t0.Sign() == 0 {
return e.err("divide by zero")
}
cr.Quo(cr, &t0) // cr = Re(a*conj(b))/|b|^2 = Re(a/b)
ci.Quo(ci, &t0) // ci = Im(a*conj(b))/|b|^2 = Im(a/b)
}
return result{nil, untComplex{cr, ci}}
}
return e.err("invalid operation")
}
// findLocalVar finds a local variable (or function parameter) by name, and
// returns its address and DWARF type. It returns a nil type on failure.
// The PC and SP are used to determine the current function and stack frame.
func (s *Server) findLocalVar(name string, pc, sp uint64) (uint64, dwarf.Type) {
// Find the DWARF entry for the function at pc.
funcEntry, _, err := s.dwarfData.PCToFunction(uint64(pc))
if err != nil {
return 0, nil
}
// Compute the stack frame pointer.
fpOffset, err := s.dwarfData.PCToSPOffset(uint64(pc))
if err != nil {
return 0, nil
}
framePointer := sp + uint64(fpOffset)
// Check each child of the function's DWARF entry to see if it is a parameter
// or local variable with the right name. If so, return its address and type.
r := s.dwarfData.Reader()
r.Seek(funcEntry.Offset)
for {
varEntry, err := r.Next()
if err != nil {
break
}
if varEntry.Tag == 0 {
// This tag marks the end of the function's DWARF entry's children.
break
}
// Check this entry corresponds to a local variable or function parameter,
// that it has the correct name, and that we can get its type and location.
// If so, return them.
if varEntry.Tag != dwarf.TagFormalParameter && varEntry.Tag != dwarf.TagVariable {
continue
}
varName, ok := varEntry.Val(dwarf.AttrName).(string)
if !ok {
continue
}
if varName != name {
continue
}
varTypeOffset, ok := varEntry.Val(dwarf.AttrType).(dwarf.Offset)
if !ok {
continue
}
varType, err := s.dwarfData.Type(varTypeOffset)
if err != nil {
continue
}
locationAttribute := varEntry.Val(dwarf.AttrLocation)
if locationAttribute == nil {
continue
}
locationDescription, ok := locationAttribute.([]uint8)
if !ok {
continue
}
frameOffset, err := evalLocation(locationDescription)
if err != nil {
continue
}
return framePointer + uint64(frameOffset), varType
}
return 0, nil
}
// findGlobalVar finds a global variable by name, and returns its address and
// DWARF type. It returns a nil type on failure.
func (s *Server) findGlobalVar(name string) (uint64, dwarf.Type) {
entry, err := s.dwarfData.LookupVariable(name)
if err != nil {
return 0, nil
}
loc, err := s.dwarfData.EntryLocation(entry)
if err != nil {
return 0, nil
}
ofs, err := s.dwarfData.EntryTypeOffset(entry)
if err != nil {
return 0, nil
}
typ, err := s.dwarfData.Type(ofs)
if err != nil {
return 0, nil
}
return loc, typ
}
// intFromInteger converts an untyped integer constant to an int32 or int64,
// depending on the int size of the debugged program.
// It returns an error on overflow, or if it can't determine the int size.
func (e *evaluator) intFromInteger(v untInt) (interface{}, error) {
t, ok := e.getBaseType("int")
if !ok {
return nil, errors.New("couldn't get int size from DWARF info")
}
switch t.Common().ByteSize {
case 4:
if v.Cmp(bigIntMaxInt32) == +1 || v.Cmp(bigIntMinInt32) == -1 {
return nil, errors.New("constant overflows int")
}
return int32(v.Int64()), nil
case 8:
if v.Cmp(bigIntMaxInt64) == +1 || v.Cmp(bigIntMinInt64) == -1 {
return nil, errors.New("constant overflows int")
}
return v.Int64(), nil
}
return nil, errors.New("invalid int size in DWARF info")
}
// uint8Result constructs a result for a uint8 value.
func (e *evaluator) uint8Result(v uint8) result {
t, ok := e.getBaseType("uint8")
if !ok {
e.err("couldn't construct uint8")
}
return result{t, uint8(v)}
}
// stringResult constructs a result for a string value.
func (e *evaluator) stringResult(s string) result {
t, ok := e.getBaseType("string")
if !ok {
e.err("couldn't construct string")
}
return result{t, debug.String{Length: uint64(len(s)), String: s}}
}
// getBaseType returns the *dwarf.Type with a given name.
// TODO: cache this.
func (e *evaluator) getBaseType(name string) (dwarf.Type, bool) {
entry, err := e.server.dwarfData.LookupEntry(name)
if err != nil {
return nil, false
}
t, err := e.server.dwarfData.Type(entry.Offset)
if err != nil {
return nil, false
}
return t, true
}
// resultFrom constructs a result corresponding to a value in the program with
// the given address and DWARF type.
// If getAddress is true, the result will be the operand of an address expression,
// so resultFrom returns a result containing a value of type addressableValue.
func (e *evaluator) resultFrom(a uint64, t dwarf.Type, getAddress bool) result {
if a == 0 {
return e.err("nil pointer dereference")
}
if getAddress {
return result{t, addressableValue{a}}
}
v, err := e.server.value(t, a)
if err != nil {
return e.err(err.Error())
}
return result{t, v}
}
// zero returns the zero value of type t.
// TODO: implement for array and struct.
func (e *evaluator) zero(t dwarf.Type) result {
var v interface{}
switch typ := followTypedefs(t).(type) {
case *dwarf.CharType, *dwarf.IntType, *dwarf.EnumType:
switch typ.Common().ByteSize {
case 1:
v = int8(0)
case 2:
v = int16(0)
case 4:
v = int32(0)
case 8:
v = int64(0)
default:
return e.err("invalid integer size " + fmt.Sprint(typ.Common().ByteSize))
}
case *dwarf.UcharType, *dwarf.UintType:
switch typ.Common().ByteSize {
case 1:
v = uint8(0)
case 2:
v = uint16(0)
case 4:
v = uint32(0)
case 8:
v = uint64(0)
default:
return e.err("invalid unsigned integer size " + fmt.Sprint(typ.Common().ByteSize))
}
case *dwarf.FloatType:
switch typ.Common().ByteSize {
case 4:
v = float32(0)
case 8:
v = float64(0)
default:
return e.err("invalid float size " + fmt.Sprint(typ.Common().ByteSize))
}
case *dwarf.ComplexType:
switch typ.Common().ByteSize {
case 8:
v = complex64(0)
case 16:
v = complex128(0)
default:
return e.err("invalid complex size " + fmt.Sprint(typ.Common().ByteSize))
}
case *dwarf.BoolType:
v = false
case *dwarf.PtrType:
v = debug.Pointer{TypeID: uint64(t.Common().Offset)}
case *dwarf.SliceType:
v = debug.Slice{
Array: debug.Array{
ElementTypeID: uint64(typ.ElemType.Common().Offset),
StrideBits: uint64(typ.ElemType.Common().ByteSize) * 8,
},
}
case *dwarf.StringType:
v = debug.String{}
case *dwarf.InterfaceType:
v = debug.Interface{}
case *dwarf.FuncType:
v = debug.Func{}
case *dwarf.MapType:
v = debug.Map{TypeID: uint64(t.Common().Offset)}
case *dwarf.ChanType:
v = debug.Channel{
ElementTypeID: uint64(typ.ElemType.Common().Offset),
Stride: uint64(typ.ElemType.Common().ByteSize),
}
default:
return e.err("can't get zero value of this type")
}
return result{t, v}
}
// convertUntyped converts x to be the same type as y, if x is untyped and the
// conversion is possible.
//
// An untyped bool can be converted to a boolean type.
// An untyped string can be converted to a string type.
// An untyped integer, rune, float or complex value can be converted to a
// numeric type, or to an untyped value later in that list.
//
// x is returned unchanged if none of these cases apply.
func convertUntyped(x, y result) result {
switch a := x.v.(type) {
case untInt:
i := a.Int
switch y.v.(type) {
case int8:
return result{y.d, int8(i.Int64())}
case int16:
return result{y.d, int16(i.Int64())}
case int32:
return result{y.d, int32(i.Int64())}
case int64:
return result{y.d, int64(i.Int64())}
case uint8:
return result{y.d, uint8(i.Uint64())}
case uint16:
return result{y.d, uint16(i.Uint64())}
case uint32:
return result{y.d, uint32(i.Uint64())}
case uint64:
return result{y.d, uint64(i.Uint64())}
case float32:
f, _ := new(big.Float).SetInt(i).Float32()
return result{y.d, f}
case float64:
f, _ := new(big.Float).SetInt(i).Float64()
return result{y.d, f}
case complex64:
f, _ := new(big.Float).SetInt(i).Float32()
return result{y.d, complex(f, 0)}
case complex128:
f, _ := new(big.Float).SetInt(i).Float64()
return result{y.d, complex(f, 0)}
case untRune:
return result{nil, untRune{i}}
case untFloat:
return result{nil, untFloat{new(big.Float).SetPrec(prec).SetInt(i)}}
case untComplex:
return result{nil, untComplex{new(big.Float).SetPrec(prec).SetInt(i), new(big.Float)}}
}
case untRune:
i := a.Int
switch y.v.(type) {
case int8:
return result{y.d, int8(i.Int64())}
case int16:
return result{y.d, int16(i.Int64())}
case int32:
return result{y.d, int32(i.Int64())}
case int64:
return result{y.d, int64(i.Int64())}
case uint8:
return result{y.d, uint8(i.Uint64())}
case uint16:
return result{y.d, uint16(i.Uint64())}
case uint32:
return result{y.d, uint32(i.Uint64())}
case uint64:
return result{y.d, uint64(i.Uint64())}
case float32:
f, _ := new(big.Float).SetInt(i).Float32()
return result{y.d, f}
case float64:
f, _ := new(big.Float).SetInt(i).Float64()
return result{y.d, f}
case complex64:
f, _ := new(big.Float).SetInt(i).Float32()
return result{y.d, complex(f, 0)}
case complex128:
f, _ := new(big.Float).SetInt(i).Float64()
return result{y.d, complex(f, 0)}
case untRune:
return result{nil, untRune{i}}
case untFloat:
return result{nil, untFloat{new(big.Float).SetPrec(prec).SetInt(i)}}
case untComplex:
return result{nil, untComplex{new(big.Float).SetPrec(prec).SetInt(i), new(big.Float)}}
}
case untFloat:
if a.IsInt() {
i, _ := a.Int(nil)
switch y.v.(type) {
case int8:
return result{y.d, int8(i.Int64())}
case int16:
return result{y.d, int16(i.Int64())}
case int32:
return result{y.d, int32(i.Int64())}
case int64:
return result{y.d, int64(i.Int64())}
case uint8:
return result{y.d, uint8(i.Uint64())}
case uint16:
return result{y.d, uint16(i.Uint64())}
case uint32:
return result{y.d, uint32(i.Uint64())}
case uint64:
return result{y.d, uint64(i.Uint64())}
}
}
switch y.v.(type) {
case float32:
f, _ := a.Float32()
return result{y.d, float32(f)}
case float64:
f, _ := a.Float64()
return result{y.d, float64(f)}
case complex64:
f, _ := a.Float32()
return result{y.d, complex(f, 0)}
case complex128:
f, _ := a.Float64()
return result{y.d, complex(f, 0)}
case untComplex:
return result{nil, untComplex{a.Float, new(big.Float)}}
}
case untComplex:
if a.i.Sign() == 0 {
// a is a real number.
if a.r.IsInt() {
// a is an integer.
i, _ := a.r.Int(nil)
switch y.v.(type) {
case int8:
return result{y.d, int8(i.Int64())}
case int16:
return result{y.d, int16(i.Int64())}
case int32:
return result{y.d, int32(i.Int64())}
case int64:
return result{y.d, int64(i.Int64())}
case uint8:
return result{y.d, uint8(i.Uint64())}
case uint16:
return result{y.d, uint16(i.Uint64())}
case uint32:
return result{y.d, uint32(i.Uint64())}
case uint64:
return result{y.d, uint64(i.Uint64())}
}
}
switch y.v.(type) {
case float32:
f, _ := a.r.Float32()
return result{y.d, float32(f)}
case float64:
f, _ := a.r.Float64()
return result{y.d, float64(f)}
}
}
switch y.v.(type) {
case complex64:
r, _ := a.r.Float32()
i, _ := a.i.Float32()
return result{y.d, complex(r, i)}
case complex128:
r, _ := a.r.Float64()
i, _ := a.i.Float64()
return result{y.d, complex(r, i)}
}
case bool:
if x.d != nil {
// x is a typed bool, not an untyped bool.
break
}
switch y.v.(type) {
case bool:
return result{y.d, bool(a)}
}
case untString:
switch y.v.(type) {
case debug.String:
return result{y.d, debug.String{Length: uint64(len(a)), String: string(a)}}
}
}
return x
}
// uint64FromResult converts a result into a uint64 for slice or index expressions.
// It returns an error if the conversion cannot be done.
func uint64FromResult(x result) (uint64, error) {
switch v := x.v.(type) {
case int8:
if v < 0 {
return 0, errors.New("value is negative")
}
return uint64(v), nil
case int16:
if v < 0 {
return 0, errors.New("value is negative")
}
return uint64(v), nil
case int32:
if v < 0 {
return 0, errors.New("value is negative")
}
return uint64(v), nil
case int64:
if v < 0 {
return 0, errors.New("value is negative")
}
return uint64(v), nil
case uint8:
return uint64(v), nil
case uint16:
return uint64(v), nil
case uint32:
return uint64(v), nil
case uint64:
return v, nil
case untInt:
if v.Int.Sign() == -1 {
return 0, errors.New("value is negative")
}
if v.Int.Cmp(bigIntMaxUint64) == +1 {
return 0, errors.New("value is too large")
}
return v.Int.Uint64(), nil
case untRune:
if v.Sign() == -1 {
return 0, errors.New("value is negative")
}
if v.Cmp(bigIntMaxUint64) == +1 {
return 0, errors.New("value is too large")
}
return v.Uint64(), nil
case untFloat:
if !v.IsInt() {
return 0, errors.New("value is not an integer")
}
if v.Sign() == -1 {
return 0, errors.New("value is negative")
}
i, _ := v.Int(nil)
if i.Cmp(bigIntMaxUint64) == +1 {
return 0, errors.New("value is too large")
}
return i.Uint64(), nil
case untComplex:
if v.i.Sign() != 0 {
return 0, errors.New("value is complex")
}
if !v.r.IsInt() {
return 0, errors.New("value is not an integer")
}
if v.r.Sign() == -1 {
return 0, errors.New("value is negative")
}
i, _ := v.r.Int(nil)
if i.Cmp(bigIntMaxUint64) == +1 {
return 0, errors.New("value is too large")
}
return i.Uint64(), nil
}
return 0, fmt.Errorf("cannot convert to unsigned integer")
}
// followTypedefs returns the underlying type of t, removing any typedefs.
// If t leads to a cycle of typedefs, followTypedefs returns nil.
func followTypedefs(t dwarf.Type) dwarf.Type {
// If t is a *dwarf.TypedefType, next returns t.Type, otherwise it returns t.
// The bool returned is true when the argument was a typedef.
next := func(t dwarf.Type) (dwarf.Type, bool) {
tt, ok := t.(*dwarf.TypedefType)
if !ok {
return t, false
}
return tt.Type, true
}
// Advance two pointers, one at twice the speed, so we can detect if we get
// stuck in a cycle.
slow, fast := t, t
for {
var wasTypedef bool
fast, wasTypedef = next(fast)
if !wasTypedef {
return fast
}
fast, wasTypedef = next(fast)
if !wasTypedef {
return fast
}
slow, _ = next(slow)
if slow == fast {
return nil
}
}
}