diff --git a/internal/gocore/gocore_test.go b/internal/gocore/gocore_test.go
index f72c5fd..e9a41b8 100644
--- a/internal/gocore/gocore_test.go
+++ b/internal/gocore/gocore_test.go
@@ -9,10 +9,12 @@
 
 import (
 	"archive/zip"
+	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"path"
 	"path/filepath"
 	"reflect"
@@ -21,6 +23,7 @@
 	"testing"
 
 	"golang.org/x/debug/internal/core"
+	"golang.org/x/debug/internal/testenv"
 )
 
 // loadTest loads a simple core file which resulted from running the
@@ -85,6 +88,139 @@
 	return p
 }
 
+// loadExampleGenerated generates a core from a binary built with
+// runtime.GOROOT().
+func loadExampleGenerated(t *testing.T) *Process {
+	t.Helper()
+	testenv.MustHaveGoBuild(t)
+	switch runtime.GOOS {
+	case "js", "plan9", "windows":
+		t.Skipf("skipping: no core files on %s", runtime.GOOS)
+	}
+	if runtime.GOARCH != "amd64" {
+		t.Skipf("skipping: only parsing of amd64 cores is supported")
+	}
+
+	cleanup := setupCorePattern(t)
+	defer cleanup()
+
+	dir := t.TempDir()
+	file, output, err := generateCore(dir)
+	t.Logf("crasher output: %s", output)
+	if err != nil {
+		t.Fatalf("generateCore() got err %v want nil", err)
+	}
+	c, err := core.Core(file, "", "")
+	if err != nil {
+		t.Fatalf("can't load test core file: %s", err)
+	}
+	p, err := Core(c)
+	if err != nil {
+		t.Fatalf("can't parse Go core: %s", err)
+	}
+	return p
+}
+
+func setupCorePattern(t *testing.T) func() {
+	if runtime.GOOS != "linux" {
+		t.Skip("skipping: core file pattern check implemented only for Linux")
+	}
+
+	const (
+		corePatternPath = "/proc/sys/kernel/core_pattern"
+		newPattern      = "core"
+	)
+
+	b, err := os.ReadFile(corePatternPath)
+	if err != nil {
+		t.Fatalf("unable to read core pattern: %v", err)
+	}
+	pattern := string(b)
+	t.Logf("original core pattern: %s", pattern)
+
+	// We want a core file in the working directory containing "core" in
+	// the name. If the pattern already matches this, there is nothing to
+	// do. What we don't want:
+	//  - Pipe to another process
+	//  - Path components
+	if !strings.HasPrefix(pattern, "|") && !strings.Contains(pattern, "/") && strings.Contains(pattern, "core") {
+		// Pattern is fine as-is, nothing to do.
+		return func() {}
+	}
+
+	if os.Getenv("GO_BUILDER_NAME") == "" {
+		// Don't change the core pattern on arbitrary machines, as it
+		// has global effect.
+		t.Skipf("skipping: unable to generate core file due to incompatible core pattern %q; set %s to %q", pattern, corePatternPath, newPattern)
+	}
+
+	t.Logf("updating core pattern to %q", newPattern)
+
+	err = os.WriteFile(corePatternPath, []byte(newPattern), 0)
+	if err != nil {
+		t.Skipf("skipping: unable to write core pattern: %v", err)
+	}
+
+	return func() {
+		t.Logf("resetting core pattern to %q", pattern)
+		err := os.WriteFile(corePatternPath, []byte(pattern), 0)
+		if err != nil {
+			t.Errorf("unable to write core pattern back to original value: %v", err)
+		}
+	}
+}
+
+func generateCore(dir string) (string, []byte, error) {
+	goTool, err := testenv.GoTool()
+	if err != nil {
+		return "", nil, fmt.Errorf("cannot find go tool: %w", err)
+	}
+
+	const source = "./testdata/coretest/test.go"
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", nil, fmt.Errorf("erroring getting cwd: %w", err)
+	}
+
+	srcPath := filepath.Join(cwd, source)
+	cmd := exec.Command(goTool, "build", "-o", "test.exe", srcPath)
+	cmd.Dir = dir
+
+	b, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", nil, fmt.Errorf("error building crasher: %w\n%s", err, string(b))
+	}
+
+	cmd = exec.Command("./test.exe")
+	cmd.Env = append(os.Environ(), "GOTRACEBACK=crash")
+	cmd.Dir = dir
+
+	b, err = cmd.CombinedOutput()
+	// We expect a crash.
+	var ee *exec.ExitError
+	if !errors.As(err, &ee) {
+		return "", b, fmt.Errorf("crasher did not crash, got err %T %w", err, err)
+	}
+
+	// Look for any file with "core" in the name.
+	dd, err := os.ReadDir(dir)
+	if err != nil {
+		return "", b, fmt.Errorf("error reading output directory: %w", err)
+	}
+
+	for _, d := range dd {
+		if strings.Contains(d.Name(), "core") {
+			return filepath.Join(dir, d.Name()), b, nil
+		}
+	}
+
+	names := make([]string, 0, len(dd))
+	for _, d := range dd {
+		names = append(names, d.Name())
+	}
+	return "", b, fmt.Errorf("did not find core file in %+v", names)
+}
+
 // unzip unpacks the zip file name into the directory dir.
 func unzip(t *testing.T, name, dir string) {
 	t.Helper()
@@ -268,16 +404,27 @@
 }
 
 func TestVersions(t *testing.T) {
-	loadExampleVersion(t, "1.10")
-	loadExampleVersion(t, "1.11")
-	loadExampleVersion(t, "1.12.zip")
-	loadExampleVersion(t, "1.13.zip")
-	loadExampleVersion(t, "1.13.3.zip")
-	loadExampleVersion(t, "1.14.zip")
-	loadExampleVersion(t, "1.16.zip")
-	loadExampleVersion(t, "1.17.zip")
-	loadExampleVersion(t, "1.18.zip")
-	loadExampleVersion(t, "1.19.zip")
+	versions := []string{
+		"1.10",
+		"1.11",
+		"1.12.zip",
+		"1.13.zip",
+		"1.13.3.zip",
+		"1.14.zip",
+		"1.16.zip",
+		"1.17.zip",
+		"1.18.zip",
+		"1.19.zip",
+	}
+	for _, ver := range versions {
+		t.Run(ver, func(t *testing.T) {
+			loadExampleVersion(t, ver)
+		})
+	}
+
+	t.Run("goroot", func(t *testing.T) {
+		loadExampleGenerated(t)
+	})
 }
 
 func loadZipCore(t *testing.T, name string) *Process {
diff --git a/internal/gocore/module.go b/internal/gocore/module.go
index 5c22b63..4f443c7 100644
--- a/internal/gocore/module.go
+++ b/internal/gocore/module.go
@@ -82,13 +82,22 @@
 // pcln must have type []byte and represent the module's pcln table region.
 func (m *module) readFunc(r region, pctab region, funcnametab region) *Func {
 	f := &Func{module: m, r: r}
-	if r.HasField("entryoff") {
+	var nameOff int32
+	switch {
+	case r.HasField("entryOff"):
+		f.entry = m.textAddr(r.Field("entryOff").Uint32())
+		nameOff = r.Field("nameOff").Int32()
+	case r.HasField("entryoff"):
+		// Prior to 1.20, entryOff and nameOff were named entryoff and
+		// nameoff, respectively.
 		f.entry = m.textAddr(r.Field("entryoff").Uint32())
-	} else {
+		nameOff = r.Field("nameoff").Int32()
+	default:
 		// Prior to 1.18, _func.entry directly referenced the entries.
 		f.entry = core.Address(r.Field("entry").Uintptr())
+		nameOff = r.Field("nameoff").Int32()
 	}
-	f.name = r.p.proc.ReadCString(funcnametab.SliceIndex(int64(r.Field("nameoff").Int32())).a)
+	f.name = r.p.proc.ReadCString(funcnametab.SliceIndex(int64(nameOff)).a)
 	pcsp := r.Field("pcsp")
 	var pcspIdx int64
 	if pcsp.typ.Kind == KindUint {
diff --git a/internal/gocore/process.go b/internal/gocore/process.go
index 6cb8554..4df8008 100644
--- a/internal/gocore/process.go
+++ b/internal/gocore/process.go
@@ -118,7 +118,7 @@
 func Core(proc *core.Process) (p *Process, err error) {
 	// Make sure we have DWARF info.
 	if _, err := proc.DWARF(); err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error reading dwarf: %w", err)
 	}
 
 	// Guard against failures of proc.Read* routines.
@@ -259,6 +259,7 @@
 				min := core.Address(arenaSize*(level2+level1*level2size) - arenaBaseOffset)
 				max := min.Add(arenaSize)
 				bitmap := a.Field("bitmap")
+				oneBitBitmap := a.HasField("noMorePtrs") // Starting in 1.20.
 				spans := a.Field("spans")
 
 				arenas = append(arenas, arena{
@@ -273,16 +274,28 @@
 				// Copy out ptr/nonptr bits
 				n := bitmap.ArrayLen()
 				for i := int64(0); i < n; i++ {
-					// The nth byte is composed of 4 object bits and 4 live/dead
-					// bits. We ignore the 4 live/dead bits, which are on the
-					// high order side of the byte.
-					//
-					// See mbitmap.go for more information on the format of
-					// the bitmap field of heapArena.
-					m := bitmap.ArrayIndex(i).Uint8()
-					for j := int64(0); j < 4; j++ {
-						if m>>uint(j)&1 != 0 {
-							p.setHeapPtr(min.Add((i*4 + j) * ptrSize))
+					if oneBitBitmap {
+						// The array uses 1 bit per word of heap. See mbitmap.go for
+						// more information.
+						m := bitmap.ArrayIndex(i).Uintptr()
+						bits := 8 * ptrSize
+						for j := int64(0); j < bits; j++ {
+							if m>>uint(j)&1 != 0 {
+								p.setHeapPtr(min.Add((i*bits + j) * ptrSize))
+							}
+						}
+					} else {
+						// The nth byte is composed of 4 object bits and 4 live/dead
+						// bits. We ignore the 4 live/dead bits, which are on the
+						// high order side of the byte.
+						//
+						// See mbitmap.go for more information on the format of
+						// the bitmap field of heapArena.
+						m := bitmap.ArrayIndex(i).Uint8()
+						for j := int64(0); j < 4; j++ {
+							if m>>uint(j)&1 != 0 {
+								p.setHeapPtr(min.Add((i*4 + j) * ptrSize))
+							}
 						}
 					}
 				}
@@ -392,6 +405,9 @@
 		if st.IsStruct() && st.HasField("s") { // go1.14+
 			st = st.Field("s")
 		}
+		if st.IsStruct() && st.HasField("value") { // go1.20+
+			st = st.Field("value")
+		}
 		switch st.Uint8() {
 		case spanInUse:
 			inUseSpanSize += spanSize
@@ -596,7 +612,11 @@
 			}
 		}
 	}
-	status := r.Field("atomicstatus").Uint32()
+	st := r.Field("atomicstatus")
+	if st.IsStruct() && st.HasField("value") { // go1.20+
+		st = st.Field("value")
+	}
+	status := st.Uint32()
 	status &^= uint32(p.rtConstants["_Gscan"])
 	var sp, pc core.Address
 	switch status {
diff --git a/internal/gocore/testdata/README b/internal/gocore/testdata/README
index fe2de04..7fa4d21 100644
--- a/internal/gocore/testdata/README
+++ b/internal/gocore/testdata/README
@@ -20,11 +20,10 @@
 steps for subsequent versions:
 
 mkdir /tmp/coretest
+rm -fr /tmp/coretest/*   # in case there's old junk there
+cp coretest/test.go /tmp/coretest
 cd /tmp/coretest
-rm -fr *   // in case there's old junk there
-cat the above program into test.go
 go build test.go
-ulimit -c unlimited
 GOTRACEBACK=crash ./test
 zip 1.12.zip /tmp/coretest/core /tmp/coretest/test  // use your version number
 
diff --git a/internal/gocore/testdata/coretest/test.go b/internal/gocore/testdata/coretest/test.go
new file mode 100644
index 0000000..7f3755c
--- /dev/null
+++ b/internal/gocore/testdata/coretest/test.go
@@ -0,0 +1,19 @@
+package main
+
+import (
+	"fmt"
+	"syscall"
+)
+
+func main() {
+	inf := int64(syscall.RLIM_INFINITY)
+	lim := syscall.Rlimit{
+		Cur: uint64(inf),
+		Max: uint64(inf),
+	}
+	if err := syscall.Setrlimit(syscall.RLIMIT_CORE, &lim); err != nil {
+		panic(fmt.Sprintf("error setting rlimit: %v", err))
+	}
+
+	_ = *(*int)(nil)
+}