diff --git a/cmd/viewcore/main.go b/cmd/viewcore/main.go
index 91ffebd..050d0ab 100644
--- a/cmd/viewcore/main.go
+++ b/cmd/viewcore/main.go
@@ -233,33 +233,33 @@
 	// copy of params used to generate p.
 	cfg config
 
-	p   *core.Process
-	err error
+	coreP   *core.Process
+	gocoreP *gocore.Process
+	err     error
 }{}
 
 // readCore reads corefile and returns core and gocore process states.
-func readCore(flags gocore.Flags) (*core.Process, *gocore.Process, error) {
+func readCore() (*core.Process, *gocore.Process, error) {
 	cc := coreCache
-	if cc.cfg != cfg {
-		cc.cfg = cfg
-		cc.p, cc.err = core.Core(cfg.corefile, cfg.base, cfg.exePath)
+	if cc.cfg == cfg {
+		return cc.coreP, cc.gocoreP, cc.err
 	}
-	if cc.err != nil {
-		return nil, nil, cc.err
-	}
-	for _, w := range cc.p.Warnings() {
-		fmt.Fprintf(os.Stderr, "WARNING: %s\n", w)
-	}
-	// TODO: Cache gocore.Core object too.
-	// The tricky part of gocore is the flags. Change gocore
-	// API to initialize parts on first use so the processed
-	// results, which are expensive, can be cached.
-	c, err := gocore.Core(cc.p, flags)
+	c, err := core.Core(cfg.corefile, cfg.base, cfg.exePath)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v\n", err)
 		return nil, nil, err
 	}
-	return cc.p, c, nil
+	p, err := gocore.Core(c)
+	if err != nil {
+		return nil, nil, err
+	}
+	for _, w := range c.Warnings() {
+		fmt.Fprintf(os.Stderr, "WARNING: %s\n", w)
+	}
+	cc.cfg = cfg
+	cc.coreP = c
+	cc.gocoreP = p
+	cc.err = nil
+	return c, p, nil
 }
 
 func runRoot(cmd *cobra.Command, args []string) {
@@ -267,7 +267,7 @@
 		cmd.Usage()
 		return
 	}
-	p, _, err := readCore(0)
+	p, _, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -346,7 +346,7 @@
 }
 
 func runOverview(cmd *cobra.Command, args []string) {
-	p, c, err := readCore(0)
+	p, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -363,7 +363,7 @@
 }
 
 func runMappings(cmd *cobra.Command, args []string) {
-	p, _, err := readCore(0)
+	p, _, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -398,7 +398,7 @@
 }
 
 func runGoroutines(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(0)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -422,7 +422,7 @@
 }
 
 func runHistogram(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(gocore.FlagTypes)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -458,7 +458,7 @@
 }
 
 func runBreakdown(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(0)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -488,7 +488,7 @@
 }
 
 func runObjgraph(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(gocore.FlagTypes)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -552,7 +552,7 @@
 }
 
 func runObjects(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(gocore.FlagTypes)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -564,7 +564,7 @@
 }
 
 func runReachable(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(gocore.FlagTypes | gocore.FlagReverse)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -648,7 +648,7 @@
 }
 
 func runHTML(cmd *cobra.Command, args []string) {
-	_, c, err := readCore(gocore.FlagTypes | gocore.FlagReverse)
+	_, c, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
@@ -656,7 +656,7 @@
 }
 
 func runRead(cmd *cobra.Command, args []string) {
-	p, _, err := readCore(0)
+	p, _, err := readCore()
 	if err != nil {
 		exitf("%v\n", err)
 	}
diff --git a/internal/gocore/dominator.go b/internal/gocore/dominator.go
index 59fac42..ca2709f 100644
--- a/internal/gocore/dominator.go
+++ b/internal/gocore/dominator.go
@@ -86,6 +86,9 @@
 }
 
 func runLT(p *Process) ltDom {
+	p.typeHeap()
+	p.reverseEdges()
+
 	nVertices := 1 + len(p.rootIdx) + p.nObj
 	lt := ltDom{
 		p:         p,
diff --git a/internal/gocore/gocore_test.go b/internal/gocore/gocore_test.go
index 8d4b96f..d85da17 100644
--- a/internal/gocore/gocore_test.go
+++ b/internal/gocore/gocore_test.go
@@ -25,7 +25,7 @@
 	if err != nil {
 		t.Fatalf("can't load test core file: %s", err)
 	}
-	p, err := Core(c, FlagTypes|FlagReverse)
+	p, err := Core(c)
 	if err != nil {
 		t.Fatalf("can't parse Go core: %s", err)
 	}
@@ -40,7 +40,7 @@
 	if err != nil {
 		t.Fatalf("can't load test core file: %s", err)
 	}
-	p, err := Core(c, FlagTypes|FlagReverse)
+	p, err := Core(c)
 	if err != nil {
 		t.Fatalf("can't parse Go core: %s", err)
 	}
diff --git a/internal/gocore/object.go b/internal/gocore/object.go
index 5765959..15d1c38 100644
--- a/internal/gocore/object.go
+++ b/internal/gocore/object.go
@@ -238,8 +238,9 @@
 
 // Type returns the type and repeat count for the object x.
 // x contains at least repeat copies of the returned type.
-// FlagTypes must have been passed to Core when p was constructed.
 func (p *Process) Type(x Object) (*Type, int64) {
+	p.typeHeap()
+
 	i, _ := p.findObjectIndex(core.Address(x))
 	return p.types[i].t, p.types[i].r
 }
diff --git a/internal/gocore/process.go b/internal/gocore/process.go
index d12feed..d4e368a 100644
--- a/internal/gocore/process.go
+++ b/internal/gocore/process.go
@@ -8,6 +8,7 @@
 	"debug/dwarf"
 	"fmt"
 	"strings"
+	"sync"
 
 	"golang.org/x/debug/internal/core"
 )
@@ -56,16 +57,16 @@
 	globals []*Root
 
 	// Types of each object, indexed by object index.
-	// Only initialized if FlagTypes is passed to Core.
-	types []typeInfo
+	initTypeHeap sync.Once
+	types        []typeInfo
 
 	// Reverse edges.
 	// The reverse edges for object #i are redge[ridx[i]:ridx[i+1]].
 	// A "reverse edge" for object #i is a location in memory where a pointer
 	// to object #i lives.
-	// Only initialized if FlagReverse is passed to Core.
-	redge []core.Address
-	ridx  []int64
+	initReverseEdges sync.Once
+	redge            []core.Address
+	ridx             []int64
 	// Sorted list of all roots.
 	// Only initialized if FlagReverse is passed to Core.
 	rootIdx []*Root
@@ -107,23 +108,8 @@
 	return s[0]
 }
 
-// A Flags indicates optional analyses for Core to compute.
-type Flags uint8
-
-const (
-	// FlagTypes requests that Core compute type information for all Go objects,
-	// required to use the Type function.
-	// Setting this flag will require more initialization time and use more memory.
-	FlagTypes Flags = 1 << iota
-	// FlagReverse requests that Core compute reverse edge information,
-	// required to use ForEachReversePtr.
-	// Setting this flag will require more initialization time and use more memory.
-	FlagReverse
-)
-
 // Core takes a loaded core file and extracts Go information from it.
-// flags is a bitmask of data that should be extracted from the core.
-func Core(proc *core.Process, flags Flags) (p *Process, err error) {
+func Core(proc *core.Process) (p *Process, err error) {
 	// Make sure we have DWARF info.
 	if _, err := proc.DWARF(); err != nil {
 		return nil, err
@@ -171,12 +157,6 @@
 	p.readGs()
 	p.readStackVars() // needs to be after readGs.
 	p.markObjects()   // needs to be after readGlobals, readStackVars.
-	if flags&FlagTypes != 0 {
-		p.typeHeap() // needs to be after markObjects.
-	}
-	if flags&FlagReverse != 0 {
-		p.reverseEdges() // needs to be after markObjects.
-	}
 
 	return p, nil
 }
diff --git a/internal/gocore/reverse.go b/internal/gocore/reverse.go
index 21cea17..40768a3 100644
--- a/internal/gocore/reverse.go
+++ b/internal/gocore/reverse.go
@@ -11,69 +11,71 @@
 )
 
 func (p *Process) reverseEdges() {
-	// First, count the number of edges into each object.
-	// This allows for efficient packing of the reverse edge storage.
-	cnt := make([]int64, p.nObj+1)
-	p.ForEachObject(func(x Object) bool {
-		p.ForEachPtr(x, func(_ int64, y Object, _ int64) bool {
-			idx, _ := p.findObjectIndex(p.Addr(y))
-			cnt[idx]++
+	p.initReverseEdges.Do(func() {
+		// First, count the number of edges into each object.
+		// This allows for efficient packing of the reverse edge storage.
+		cnt := make([]int64, p.nObj+1)
+		p.ForEachObject(func(x Object) bool {
+			p.ForEachPtr(x, func(_ int64, y Object, _ int64) bool {
+				idx, _ := p.findObjectIndex(p.Addr(y))
+				cnt[idx]++
+				return true
+			})
 			return true
 		})
-		return true
-	})
-	p.ForEachRoot(func(r *Root) bool {
-		p.ForEachRootPtr(r, func(_ int64, y Object, _ int64) bool {
-			idx, _ := p.findObjectIndex(p.Addr(y))
-			cnt[idx]++
+		p.ForEachRoot(func(r *Root) bool {
+			p.ForEachRootPtr(r, func(_ int64, y Object, _ int64) bool {
+				idx, _ := p.findObjectIndex(p.Addr(y))
+				cnt[idx]++
+				return true
+			})
 			return true
 		})
-		return true
-	})
 
-	// Compute cumulative count of all incoming edges up to and including each object.
-	var n int64
-	for idx, c := range cnt {
-		n += c
-		cnt[idx] = n
-	}
+		// Compute cumulative count of all incoming edges up to and including each object.
+		var n int64
+		for idx, c := range cnt {
+			n += c
+			cnt[idx] = n
+		}
 
-	// Allocate all the storage for the reverse edges.
-	p.redge = make([]core.Address, n)
+		// Allocate all the storage for the reverse edges.
+		p.redge = make([]core.Address, n)
 
-	// Add edges to the lists.
-	p.ForEachObject(func(x Object) bool {
-		p.ForEachPtr(x, func(i int64, y Object, _ int64) bool {
-			idx, _ := p.findObjectIndex(p.Addr(y))
-			e := cnt[idx]
-			e--
-			cnt[idx] = e
-			p.redge[e] = p.Addr(x).Add(i)
+		// Add edges to the lists.
+		p.ForEachObject(func(x Object) bool {
+			p.ForEachPtr(x, func(i int64, y Object, _ int64) bool {
+				idx, _ := p.findObjectIndex(p.Addr(y))
+				e := cnt[idx]
+				e--
+				cnt[idx] = e
+				p.redge[e] = p.Addr(x).Add(i)
+				return true
+			})
 			return true
 		})
-		return true
-	})
-	p.ForEachRoot(func(r *Root) bool {
-		p.ForEachRootPtr(r, func(i int64, y Object, _ int64) bool {
-			idx, _ := p.findObjectIndex(p.Addr(y))
-			e := cnt[idx]
-			e--
-			cnt[idx] = e
-			p.redge[e] = r.Addr.Add(i)
+		p.ForEachRoot(func(r *Root) bool {
+			p.ForEachRootPtr(r, func(i int64, y Object, _ int64) bool {
+				idx, _ := p.findObjectIndex(p.Addr(y))
+				e := cnt[idx]
+				e--
+				cnt[idx] = e
+				p.redge[e] = r.Addr.Add(i)
+				return true
+			})
 			return true
 		})
-		return true
-	})
-	// At this point, cnt contains the cumulative count of all edges up to
-	// but *not* including each object.
-	p.ridx = cnt
+		// At this point, cnt contains the cumulative count of all edges up to
+		// but *not* including each object.
+		p.ridx = cnt
 
-	// Make root index.
-	p.ForEachRoot(func(r *Root) bool {
-		p.rootIdx = append(p.rootIdx, r)
-		return true
+		// Make root index.
+		p.ForEachRoot(func(r *Root) bool {
+			p.rootIdx = append(p.rootIdx, r)
+			return true
+		})
+		sort.Slice(p.rootIdx, func(i, j int) bool { return p.rootIdx[i].Addr < p.rootIdx[j].Addr })
 	})
-	sort.Slice(p.rootIdx, func(i, j int) bool { return p.rootIdx[i].Addr < p.rootIdx[j].Addr })
 }
 
 // ForEachReversePtr calls fn for all pointers it finds pointing to y.
@@ -82,8 +84,9 @@
 //   the offset i in that object or root where the pointer appears.
 //   the offset j in y where the pointer points.
 // If fn returns false, ForEachReversePtr returns immediately.
-// FlagReverse must have been passed to Core when p was constructed.
 func (p *Process) ForEachReversePtr(y Object, fn func(x Object, r *Root, i, j int64) bool) {
+	p.reverseEdges()
+
 	idx, _ := p.findObjectIndex(p.Addr(y))
 	for _, a := range p.redge[p.ridx[idx]:p.ridx[idx+1]] {
 		// Read pointer, compute offset in y.
diff --git a/internal/gocore/type.go b/internal/gocore/type.go
index 05ba59b..4f564fc 100644
--- a/internal/gocore/type.go
+++ b/internal/gocore/type.go
@@ -326,174 +326,176 @@
 
 // typeHeap tries to label all the heap objects with types.
 func (p *Process) typeHeap() {
-	// Type info for the start of each object. a.k.a. "0 offset" typings.
-	p.types = make([]typeInfo, p.nObj)
+	p.initTypeHeap.Do(func() {
+		// Type info for the start of each object. a.k.a. "0 offset" typings.
+		p.types = make([]typeInfo, p.nObj)
 
-	// Type info for the interior of objects, a.k.a. ">0 offset" typings.
-	// Type information is arranged in chunks. Chunks are stored in an
-	// arbitrary order, and are guaranteed to not overlap. If types are
-	// equal, chunks are also guaranteed not to abut.
-	// Interior typings are kept separate because they hopefully are rare.
-	// TODO: They aren't really that rare. On some large heaps I tried
-	// ~50% of objects have an interior pointer into them.
-	// Keyed by object index.
-	interior := map[int][]typeChunk{}
+		// Type info for the interior of objects, a.k.a. ">0 offset" typings.
+		// Type information is arranged in chunks. Chunks are stored in an
+		// arbitrary order, and are guaranteed to not overlap. If types are
+		// equal, chunks are also guaranteed not to abut.
+		// Interior typings are kept separate because they hopefully are rare.
+		// TODO: They aren't really that rare. On some large heaps I tried
+		// ~50% of objects have an interior pointer into them.
+		// Keyed by object index.
+		interior := map[int][]typeChunk{}
 
-	// Typings we know about but haven't scanned yet.
-	type workRecord struct {
-		a core.Address
-		t *Type
-		r int64
-	}
-	var work []workRecord
-
-	// add records the fact that we know the object at address a has
-	// r copies of type t.
-	add := func(a core.Address, t *Type, r int64) {
-		if a == 0 { // nil pointer
-			return
+		// Typings we know about but haven't scanned yet.
+		type workRecord struct {
+			a core.Address
+			t *Type
+			r int64
 		}
-		i, off := p.findObjectIndex(a)
-		if i < 0 { // pointer doesn't point to an object in the Go heap
-			return
-		}
-		if off == 0 {
-			// We have a 0-offset typing. Replace existing 0-offset typing
-			// if the new one is larger.
-			ot := p.types[i].t
-			or := p.types[i].r
-			if ot == nil || r*t.Size > or*ot.Size {
-				if t == ot {
-					// Scan just the new section.
-					work = append(work, workRecord{
-						a: a.Add(or * ot.Size),
-						t: t,
-						r: r - or,
-					})
-				} else {
-					// Rescan the whole typing using the updated type.
-					work = append(work, workRecord{
-						a: a,
-						t: t,
-						r: r,
-					})
-				}
-				p.types[i].t = t
-				p.types[i].r = r
+		var work []workRecord
+
+		// add records the fact that we know the object at address a has
+		// r copies of type t.
+		add := func(a core.Address, t *Type, r int64) {
+			if a == 0 { // nil pointer
+				return
 			}
-			return
-		}
+			i, off := p.findObjectIndex(a)
+			if i < 0 { // pointer doesn't point to an object in the Go heap
+				return
+			}
+			if off == 0 {
+				// We have a 0-offset typing. Replace existing 0-offset typing
+				// if the new one is larger.
+				ot := p.types[i].t
+				or := p.types[i].r
+				if ot == nil || r*t.Size > or*ot.Size {
+					if t == ot {
+						// Scan just the new section.
+						work = append(work, workRecord{
+							a: a.Add(or * ot.Size),
+							t: t,
+							r: r - or,
+						})
+					} else {
+						// Rescan the whole typing using the updated type.
+						work = append(work, workRecord{
+							a: a,
+							t: t,
+							r: r,
+						})
+					}
+					p.types[i].t = t
+					p.types[i].r = r
+				}
+				return
+			}
 
-		// Add an interior typing to object #i.
-		c := typeChunk{off: off, t: t, r: r}
+			// Add an interior typing to object #i.
+			c := typeChunk{off: off, t: t, r: r}
 
-		// Merge the given typing into the chunks we already know.
-		// TODO: this could be O(n) per insert if there are lots of internal pointers.
-		chunks := interior[i]
-		newchunks := chunks[:0]
-		addWork := true
-		for _, d := range chunks {
-			if c.max() <= d.min() || c.min() >= d.max() {
-				// c does not overlap with d.
-				if c.t == d.t && (c.max() == d.min() || c.min() == d.max()) {
-					// c and d abut and share the same base type. Merge them.
+			// Merge the given typing into the chunks we already know.
+			// TODO: this could be O(n) per insert if there are lots of internal pointers.
+			chunks := interior[i]
+			newchunks := chunks[:0]
+			addWork := true
+			for _, d := range chunks {
+				if c.max() <= d.min() || c.min() >= d.max() {
+					// c does not overlap with d.
+					if c.t == d.t && (c.max() == d.min() || c.min() == d.max()) {
+						// c and d abut and share the same base type. Merge them.
+						c = c.merge(d)
+						continue
+					}
+					// Keep existing chunk d.
+					// Overwrites chunks slice, but we're only merging chunks so it
+					// can't overwrite to-be-processed elements.
+					newchunks = append(newchunks, d)
+					continue
+				}
+				// There is some overlap. There are a few possibilities:
+				// 1) One is completely contained in the other.
+				// 2) Both are slices of a larger underlying array.
+				// 3) Some unsafe trickery has happened. Non-containing overlap
+				//    can only happen in safe Go via case 2.
+				if c.min() >= d.min() && c.max() <= d.max() {
+					// 1a: c is contained within the existing chunk d.
+					// Note that there can be a type mismatch between c and d,
+					// but we don't care. We use the larger chunk regardless.
+					c = d
+					addWork = false // We've already scanned all of c.
+					continue
+				}
+				if d.min() >= c.min() && d.max() <= c.max() {
+					// 1b: existing chunk d is completely covered by c.
+					continue
+				}
+				if c.t == d.t && c.matchingAlignment(d) {
+					// Union two regions of the same base type. Case 2 above.
 					c = c.merge(d)
 					continue
 				}
-				// Keep existing chunk d.
-				// Overwrites chunks slice, but we're only merging chunks so it
-				// can't overwrite to-be-processed elements.
-				newchunks = append(newchunks, d)
-				continue
-			}
-			// There is some overlap. There are a few possibilities:
-			// 1) One is completely contained in the other.
-			// 2) Both are slices of a larger underlying array.
-			// 3) Some unsafe trickery has happened. Non-containing overlap
-			//    can only happen in safe Go via case 2.
-			if c.min() >= d.min() && c.max() <= d.max() {
-				// 1a: c is contained within the existing chunk d.
-				// Note that there can be a type mismatch between c and d,
-				// but we don't care. We use the larger chunk regardless.
-				c = d
-				addWork = false // We've already scanned all of c.
-				continue
-			}
-			if d.min() >= c.min() && d.max() <= c.max() {
-				// 1b: existing chunk d is completely covered by c.
-				continue
-			}
-			if c.t == d.t && c.matchingAlignment(d) {
-				// Union two regions of the same base type. Case 2 above.
-				c = c.merge(d)
-				continue
-			}
-			if c.size() < d.size() {
-				// Keep the larger of the two chunks.
-				c = d
-				addWork = false
-			}
-		}
-		// Add new chunk to list of chunks for object.
-		newchunks = append(newchunks, c)
-		interior[i] = newchunks
-		// Also arrange to scan the new chunk. Note that if we merged
-		// with an existing chunk (or chunks), those will get rescanned.
-		// Duplicate work, but that's ok. TODO: but could be expensive.
-		if addWork {
-			work = append(work, workRecord{
-				a: a.Add(c.off - off),
-				t: c.t,
-				r: c.r,
-			})
-		}
-	}
-
-	// Get typings starting at roots.
-	fr := &frameReader{p: p}
-	p.ForEachRoot(func(r *Root) bool {
-		if r.Frame != nil {
-			fr.live = r.Frame.Live
-			p.typeObject(r.Addr, r.Type, fr, add)
-		} else {
-			p.typeObject(r.Addr, r.Type, p.proc, add)
-		}
-		return true
-	})
-
-	// Propagate typings through the heap.
-	for len(work) > 0 {
-		c := work[len(work)-1]
-		work = work[:len(work)-1]
-		for i := int64(0); i < c.r; i++ {
-			p.typeObject(c.a.Add(i*c.t.Size), c.t, p.proc, add)
-		}
-	}
-
-	// Merge any interior typings with the 0-offset typing.
-	for i, chunks := range interior {
-		t := p.types[i].t
-		r := p.types[i].r
-		if t == nil {
-			continue // We have no type info at offset 0.
-		}
-		for _, c := range chunks {
-			if c.max() <= r*t.Size {
-				// c is completely contained in the 0-offset typing. Ignore it.
-				continue
-			}
-			if c.min() <= r*t.Size {
-				// Typings overlap or abut. Extend if we can.
-				if c.t == t && c.min()%t.Size == 0 {
-					r = c.max() / t.Size
-					p.types[i].r = r
+				if c.size() < d.size() {
+					// Keep the larger of the two chunks.
+					c = d
+					addWork = false
 				}
-				continue
 			}
-			// Note: at this point we throw away any interior typings that weren't
-			// merged with the 0-offset typing.  TODO: make more use of this info.
+			// Add new chunk to list of chunks for object.
+			newchunks = append(newchunks, c)
+			interior[i] = newchunks
+			// Also arrange to scan the new chunk. Note that if we merged
+			// with an existing chunk (or chunks), those will get rescanned.
+			// Duplicate work, but that's ok. TODO: but could be expensive.
+			if addWork {
+				work = append(work, workRecord{
+					a: a.Add(c.off - off),
+					t: c.t,
+					r: c.r,
+				})
+			}
 		}
-	}
+
+		// Get typings starting at roots.
+		fr := &frameReader{p: p}
+		p.ForEachRoot(func(r *Root) bool {
+			if r.Frame != nil {
+				fr.live = r.Frame.Live
+				p.typeObject(r.Addr, r.Type, fr, add)
+			} else {
+				p.typeObject(r.Addr, r.Type, p.proc, add)
+			}
+			return true
+		})
+
+		// Propagate typings through the heap.
+		for len(work) > 0 {
+			c := work[len(work)-1]
+			work = work[:len(work)-1]
+			for i := int64(0); i < c.r; i++ {
+				p.typeObject(c.a.Add(i*c.t.Size), c.t, p.proc, add)
+			}
+		}
+
+		// Merge any interior typings with the 0-offset typing.
+		for i, chunks := range interior {
+			t := p.types[i].t
+			r := p.types[i].r
+			if t == nil {
+				continue // We have no type info at offset 0.
+			}
+			for _, c := range chunks {
+				if c.max() <= r*t.Size {
+					// c is completely contained in the 0-offset typing. Ignore it.
+					continue
+				}
+				if c.min() <= r*t.Size {
+					// Typings overlap or abut. Extend if we can.
+					if c.t == t && c.min()%t.Size == 0 {
+						r = c.max() / t.Size
+						p.types[i].r = r
+					}
+					continue
+				}
+				// Note: at this point we throw away any interior typings that weren't
+				// merged with the 0-offset typing.  TODO: make more use of this info.
+			}
+		}
+	})
 }
 
 type reader interface {