x/debug: allow various internal struct fields to be signed or unsigned.

The DWARF output can change between compiler versions.

Change-Id: I2f1d7d1fed854ef6ad5aafa94b08bd73ce410506
Reviewed-on: https://go-review.googlesource.com/12402
Reviewed-by: Rob Pike <r@golang.org>

ogle/program/server/peek.go

diff --git a/ogle/program/server/peek.go b/ogle/program/server/peek.go
index 484b3f1..a2f03ce 100644
--- a/ogle/program/server/peek.go
+++ b/ogle/program/server/peek.go
@@ -66,6 +66,33 @@
 	return s.peekPtr(addr + uint64(f.ByteOffset))
 }
 
+// peekUintOrIntStructField reads a signed or unsigned integer in the field fieldName
+// of the struct of type t at addr. If the value is negative, it returns an error.
+// This function is used when the value should be non-negative, but the DWARF
+// type of the field may be signed or unsigned.
+func (s *Server) peekUintOrIntStructField(t *dwarf.StructType, addr uint64, fieldName string) (uint64, error) {
+	f, err := getField(t, fieldName)
+	if err != nil {
+		return 0, fmt.Errorf("reading field %s: %s", fieldName, err)
+	}
+	ut, ok := f.Type.(*dwarf.UintType)
+	if ok {
+		return s.peekUint(addr+uint64(f.ByteOffset), ut.ByteSize)
+	}
+	it, ok := f.Type.(*dwarf.IntType)
+	if !ok {
+		return 0, fmt.Errorf("field %s is not an integer", fieldName)
+	}
+	i, err := s.peekInt(addr+uint64(f.ByteOffset), it.ByteSize)
+	if err != nil {
+		return 0, err
+	}
+	if i < 0 {
+		return 0, fmt.Errorf("field %s is negative", fieldName)
+	}
+	return uint64(i), nil
+}
+
 // peekUintStructField reads a uint in the field fieldName of the struct
 // of type t at addr.  The size of the uint is determined by the field.
 func (s *Server) peekUintStructField(t *dwarf.StructType, addr uint64, fieldName string) (uint64, error) {

ogle/program/server/print.go

diff --git a/ogle/program/server/print.go b/ogle/program/server/print.go
index f78a2cb..b133dd3 100644
--- a/ogle/program/server/print.go
+++ b/ogle/program/server/print.go
@@ -584,12 +584,12 @@
 
 	// Print the channel buffer's length (qcount) and capacity (dataqsiz),
 	// if not 0/0.
-	qcount, err := p.server.peekUintStructField(st, a, "qcount")
+	qcount, err := p.server.peekUintOrIntStructField(st, a, "qcount")
 	if err != nil {
 		p.errorf("reading channel: %s", err)
 		return
 	}
-	dataqsiz, err := p.server.peekUintStructField(st, a, "dataqsiz")
+	dataqsiz, err := p.server.peekUintOrIntStructField(st, a, "dataqsiz")
 	if err != nil {
 		p.errorf("reading channel: %s", err)
 		return
@@ -607,24 +607,16 @@
 		p.errorf("reading slice: %s", err)
 		return
 	}
-	length, err := p.server.peekIntStructField(&typ.StructType, a, "len")
+	length, err := p.server.peekUintOrIntStructField(&typ.StructType, a, "len")
 	if err != nil {
-		var u uint64
-		u, err = p.server.peekUintStructField(&typ.StructType, a, "len")
-		if err != nil {
-			p.errorf("reading slice: %s", err)
-			return
-		}
-		length = int64(u)
+		p.errorf("reading slice: %s", err)
+		return
 	}
 	// Capacity is not used yet.
-	_, err = p.server.peekIntStructField(&typ.StructType, a, "cap")
+	_, err = p.server.peekUintOrIntStructField(&typ.StructType, a, "cap")
 	if err != nil {
-		_, err = p.server.peekUintStructField(&typ.StructType, a, "cap")
-		if err != nil {
-			p.errorf("reading slice: %s", err)
-			return
-		}
+		p.errorf("reading slice: %s", err)
+		return
 	}
 	elemType := typ.ElemType
 	size, ok := p.sizeof(typ.ElemType)
@@ -632,7 +624,7 @@
 		p.errorf("can't determine element size")
 	}
 	p.printf("%s{", typ)
-	for i := int64(0); i < length; i++ {
+	for i := uint64(0); i < length; i++ {
 		if i != 0 {
 			p.printf(", ")
 		}
@@ -649,7 +641,7 @@
 		p.errorf("reading string: %s", err)
 		return
 	}
-	length, err := p.server.peekIntStructField(&typ.StructType, a, "len")
+	length, err := p.server.peekUintOrIntStructField(&typ.StructType, a, "len")
 	if err != nil {
 		p.errorf("reading string: %s", err)
 		return