diff --git a/server/peek.go b/server/peek.go
index 936b3ab..a26677d 100644
--- a/server/peek.go
+++ b/server/peek.go
@@ -10,6 +10,7 @@
 	"errors"
 	"fmt"
 
+	"golang.org/x/debug"
 	"golang.org/x/debug/dwarf"
 )
 
@@ -54,6 +55,35 @@
 	return s.arch.UintN(buf), nil
 }
 
+// peekSlice reads the header of a slice with the given type and address.
+func (s *Server) peekSlice(t *dwarf.SliceType, addr uint64) (debug.Slice, error) {
+	ptr, err := s.peekPtrStructField(&t.StructType, addr, "array")
+	if err != nil {
+		return debug.Slice{}, fmt.Errorf("reading slice location: %s", err)
+	}
+	length, err := s.peekUintOrIntStructField(&t.StructType, addr, "len")
+	if err != nil {
+		return debug.Slice{}, fmt.Errorf("reading slice length: %s", err)
+	}
+	capacity, err := s.peekUintOrIntStructField(&t.StructType, addr, "cap")
+	if err != nil {
+		return debug.Slice{}, fmt.Errorf("reading slice capacity: %s", err)
+	}
+	if capacity < length {
+		return debug.Slice{}, fmt.Errorf("slice's capacity %d is less than its length %d", capacity, length)
+	}
+
+	return debug.Slice{
+		debug.Array{
+			ElementTypeID: uint64(t.ElemType.Common().Offset),
+			Address:       uint64(ptr),
+			Length:        length,
+			StrideBits:    uint64(t.ElemType.Common().ByteSize) * 8,
+		},
+		capacity,
+	}, nil
+}
+
 // peekString reads a string of the given type at the given address.
 // At most byteLimit bytes will be read.  If the string is longer, "..." is appended.
 func (s *Server) peekString(typ *dwarf.StringType, a uint64, byteLimit uint64) (string, error) {
diff --git a/server/server.go b/server/server.go
index 584ed5b..640895e 100644
--- a/server/server.go
+++ b/server/server.go
@@ -909,66 +909,101 @@
 		return errors.New("runtime.g is not a struct")
 	}
 
-	// Read runtime.allg.
-	allgEntry, err := s.dwarfData.LookupEntry("runtime.allg")
-	if err != nil {
-		return err
-	}
-	allgAddr, err := s.dwarfData.EntryLocation(allgEntry)
-	if err != nil {
-		return err
-	}
-	allg, err := s.peekPtr(allgAddr)
-	if err != nil {
-		return fmt.Errorf("reading allg: %v", err)
-	}
-
-	// Read runtime.allglen.
-	allglenEntry, err := s.dwarfData.LookupEntry("runtime.allglen")
-	if err != nil {
-		return err
-	}
-	off, err := s.dwarfData.EntryTypeOffset(allglenEntry)
-	if err != nil {
-		return err
-	}
-	allglenType, err := s.dwarfData.Type(off)
-	if err != nil {
-		return err
-	}
-	allglenAddr, err := s.dwarfData.EntryLocation(allglenEntry)
-	if err != nil {
-		return err
-	}
-	var allglen uint64
-	switch followTypedefs(allglenType).(type) {
-	case *dwarf.UintType, *dwarf.IntType:
-		allglen, err = s.peekUint(allglenAddr, allglenType.Common().ByteSize)
+	var (
+		allgPtr, allgLen uint64
+		allgPtrOk        bool
+	)
+	for {
+		// Try to read the slice runtime.allgs.
+		allgsEntry, err := s.dwarfData.LookupEntry("runtime.allgs")
 		if err != nil {
-			return fmt.Errorf("reading allglen: %v", err)
-		}
-	default:
-		// Some runtimes don't specify the type for allglen.  Assume it's uint32.
-		allglen, err = s.peekUint(allglenAddr, 4)
-		if err != nil {
-			return fmt.Errorf("reading allglen: %v", err)
-		}
-		if allglen != 0 {
 			break
 		}
-		// Zero?  Let's try uint64.
-		allglen, err = s.peekUint(allglenAddr, 8)
+		allgsAddr, err := s.dwarfData.EntryLocation(allgsEntry)
 		if err != nil {
-			return fmt.Errorf("reading allglen: %v", err)
+			break
+		}
+		off, err := s.dwarfData.EntryTypeOffset(allgsEntry)
+		if err != nil {
+			break
+		}
+		t, err := s.dwarfData.Type(off)
+		if err != nil {
+			break
+		}
+		allgsType, ok := followTypedefs(t).(*dwarf.SliceType)
+		if !ok {
+			break
+		}
+		allgs, err := s.peekSlice(allgsType, allgsAddr)
+		if err != nil {
+			break
+		}
+
+		allgPtr, allgLen, allgPtrOk = allgs.Address, allgs.Length, true
+		break
+	}
+	if !allgPtrOk {
+		// Read runtime.allg.
+		allgEntry, err := s.dwarfData.LookupEntry("runtime.allg")
+		if err != nil {
+			return err
+		}
+		allgAddr, err := s.dwarfData.EntryLocation(allgEntry)
+		if err != nil {
+			return err
+		}
+		allgPtr, err = s.peekPtr(allgAddr)
+		if err != nil {
+			return fmt.Errorf("reading allg: %v", err)
+		}
+
+		// Read runtime.allglen.
+		allglenEntry, err := s.dwarfData.LookupEntry("runtime.allglen")
+		if err != nil {
+			return err
+		}
+		off, err := s.dwarfData.EntryTypeOffset(allglenEntry)
+		if err != nil {
+			return err
+		}
+		allglenType, err := s.dwarfData.Type(off)
+		if err != nil {
+			return err
+		}
+		allglenAddr, err := s.dwarfData.EntryLocation(allglenEntry)
+		if err != nil {
+			return err
+		}
+		switch followTypedefs(allglenType).(type) {
+		case *dwarf.UintType, *dwarf.IntType:
+			allgLen, err = s.peekUint(allglenAddr, allglenType.Common().ByteSize)
+			if err != nil {
+				return fmt.Errorf("reading allglen: %v", err)
+			}
+		default:
+			// Some runtimes don't specify the type for allglen.  Assume it's uint32.
+			allgLen, err = s.peekUint(allglenAddr, 4)
+			if err != nil {
+				return fmt.Errorf("reading allglen: %v", err)
+			}
+			if allgLen != 0 {
+				break
+			}
+			// Zero?  Let's try uint64.
+			allgLen, err = s.peekUint(allglenAddr, 8)
+			if err != nil {
+				return fmt.Errorf("reading allglen: %v", err)
+			}
 		}
 	}
 
 	// Initialize s.goroutineStack.
 	s.goroutineStackOnce.Do(func() { s.goroutineStackInit(gType) })
 
-	for i := uint64(0); i < allglen; i++ {
+	for i := uint64(0); i < allgLen; i++ {
 		// allg is an array of pointers to g structs.  Read allg[i].
-		g, err := s.peekPtr(allg + i*uint64(s.arch.PointerSize))
+		g, err := s.peekPtr(allgPtr + i*uint64(s.arch.PointerSize))
 		if err != nil {
 			return err
 		}
diff --git a/server/value.go b/server/value.go
index 0fef7fe..e5bb0d2 100644
--- a/server/value.go
+++ b/server/value.go
@@ -120,31 +120,11 @@
 			Address: uint64(s.arch.Uintptr(buf)),
 		}, nil
 	case *dwarf.SliceType:
-		ptr, err := s.peekPtrStructField(&t.StructType, addr, "array")
-		if err != nil {
-			return nil, fmt.Errorf("reading slice location: %s", err)
+		if s, err := s.peekSlice(t, addr); err != nil {
+			return nil, err
+		} else {
+			return s, nil
 		}
-		length, err := s.peekUintOrIntStructField(&t.StructType, addr, "len")
-		if err != nil {
-			return nil, fmt.Errorf("reading slice length: %s", err)
-		}
-		capacity, err := s.peekUintOrIntStructField(&t.StructType, addr, "cap")
-		if err != nil {
-			return nil, fmt.Errorf("reading slice capacity: %s", err)
-		}
-		if capacity < length {
-			return nil, fmt.Errorf("slice's capacity %d is less than its length %d", capacity, length)
-		}
-
-		return debug.Slice{
-			debug.Array{
-				ElementTypeID: uint64(t.ElemType.Common().Offset),
-				Address:       uint64(ptr),
-				Length:        length,
-				StrideBits:    uint64(t.ElemType.Common().ByteSize) * 8,
-			},
-			capacity,
-		}, nil
 	case *dwarf.ArrayType:
 		length := t.Count
 		stride := t.StrideBitSize