diff --git a/internal/gocore/gocore_test.go b/internal/gocore/gocore_test.go
index 5f8bfd3..ce50b5d 100644
--- a/internal/gocore/gocore_test.go
+++ b/internal/gocore/gocore_test.go
@@ -276,6 +276,7 @@
 	loadExampleVersion(t, "1.14.zip")
 	loadExampleVersion(t, "1.16.zip")
 	loadExampleVersion(t, "1.17.zip")
+	loadExampleVersion(t, "1.18.zip")
 }
 
 func loadZipCore(t *testing.T, name string) *Process {
diff --git a/internal/gocore/module.go b/internal/gocore/module.go
index aacbd0c..f17c181 100644
--- a/internal/gocore/module.go
+++ b/internal/gocore/module.go
@@ -46,9 +46,21 @@
 	n := ftab.SliceLen() - 1 // last slot is a dummy, just holds entry
 	for i := int64(0); i < n; i++ {
 		ft := ftab.SliceIndex(i)
-		min := core.Address(ft.Field("entry").Uintptr())
-		max := core.Address(ftab.SliceIndex(i + 1).Field("entry").Uintptr())
-		fr := pcln.SliceIndex(int64(ft.Field("funcoff").Uintptr())).Cast("runtime._func")
+		var min, max core.Address
+		var funcoff int64
+		if p.minorVersion >= 18 {
+			min = m.textAddr(ft.Field("entryoff").Uint32())
+			max = m.textAddr(ftab.SliceIndex(i + 1).Field("entryoff").Uint32())
+			funcoff = int64(ft.Field("funcoff").Uint32())
+		} else {
+			// Prior to 1.18, functab.entry directly referenced the
+			// entries.
+			min = core.Address(ft.Field("entry").Uintptr())
+			max = core.Address(ftab.SliceIndex(i + 1).Field("entry").Uintptr())
+			// funcoff changed type, but had the same meaning.
+			funcoff = int64(ft.Field("funcoff").Uintptr())
+		}
+		fr := pcln.SliceIndex(funcoff).Cast("runtime._func")
 		var f *Func
 		if p.minorVersion >= 16 {
 			f = m.readFunc(fr, pctab, funcnametab)
@@ -69,7 +81,12 @@
 // 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}
-	f.entry = core.Address(r.Field("entry").Uintptr())
+	if m.p.minorVersion >= 18 {
+		f.entry = m.textAddr(r.Field("entryoff").Uint32())
+	} else {
+		// Prior to 1.18, _func.entry directly referenced the entries.
+		f.entry = core.Address(r.Field("entry").Uintptr())
+	}
 	f.name = r.p.proc.ReadCString(funcnametab.SliceIndex(int64(r.Field("nameoff").Int32())).a)
 	pcsp := r.Field("pcsp")
 	var pcspIdx int64
@@ -106,8 +123,22 @@
 		n = uint32(nfd.Int32())
 	}
 	for i := uint32(0); i < n; i++ {
-		f.funcdata = append(f.funcdata, r.p.proc.ReadPtr(a))
-		a = a.Add(r.p.proc.PtrSize())
+		if m.p.minorVersion >= 18 {
+			// Since 1.18, funcdata contains offsets from go.func.*.
+			off := r.p.proc.ReadUint32(a)
+			if off == ^uint32(0) {
+				// No entry.
+				f.funcdata = append(f.funcdata, 0)
+			} else {
+				f.funcdata = append(f.funcdata, core.Address(m.r.Field("gofunc").Uintptr() + uint64(off)))
+			}
+			a = a.Add(4)
+		} else {
+			// Prior to 1.18, funcdata contains pointers directly
+			// to the data.
+			f.funcdata = append(f.funcdata, r.p.proc.ReadPtr(a))
+			a = a.Add(r.p.proc.PtrSize())
+		}
 	}
 
 	// Read pcln tables we need.
@@ -120,6 +151,32 @@
 	return f
 }
 
+// textAddr returns the address of a text offset.
+//
+// Equivalent to runtime.moduledata.textAddr.
+func (m *module) textAddr(off32 uint32) core.Address {
+	off := uint64(off32)
+	res := m.r.Field("text").Uintptr() + off
+
+	textsectmap := m.r.Field("textsectmap")
+	length := textsectmap.SliceLen()
+	if length > 1 {
+		for i := int64(0); i < length; i++ {
+			sect := textsectmap.SliceIndex(i)
+
+			vaddr := sect.Field("vaddr").Uintptr()
+			end := sect.Field("end").Uintptr()
+			baseaddr := sect.Field("baseaddr").Uintptr()
+
+			if off >= vaddr && off < end || (i == length-1 && off == end) {
+				res = baseaddr + off - vaddr
+			}
+		}
+	}
+
+	return core.Address(res)
+}
+
 type funcTabEntry struct {
 	min, max core.Address
 	f        *Func
diff --git a/internal/gocore/process.go b/internal/gocore/process.go
index c46a731..6bc6960 100644
--- a/internal/gocore/process.go
+++ b/internal/gocore/process.go
@@ -678,46 +678,55 @@
 	// Find live ptrs in locals
 	live := map[core.Address]bool{}
 	if x := int(p.rtConstants["_FUNCDATA_LocalsPointerMaps"]); x < len(f.funcdata) {
-		locals := region{p: p, a: f.funcdata[x], typ: p.findType("runtime.stackmap")}
-		n := locals.Field("n").Int32()       // # of bitmaps
-		nbit := locals.Field("nbit").Int32() // # of bits per bitmap
-		idx, err := f.stackMap.find(off)
-		if err != nil {
-			return nil, fmt.Errorf("cannot read stack map at pc=%#x: %v", pc, err)
-		}
-		if idx < 0 {
-			idx = 0
-		}
-		if idx < int64(n) {
-			bits := locals.Field("bytedata").a.Add(int64(nbit+7) / 8 * idx)
-			base := frame.max.Add(-16).Add(-int64(nbit) * p.proc.PtrSize())
-			// TODO: -16 for amd64. Return address and parent's frame pointer
-			for i := int64(0); i < int64(nbit); i++ {
-				if p.proc.ReadUint8(bits.Add(i/8))>>uint(i&7)&1 != 0 {
-					live[base.Add(i*p.proc.PtrSize())] = true
+		addr := f.funcdata[x]
+		// TODO: Ideally we should have the same frame size check as
+		// runtime.getStackSize to detect errors when we are missing
+		// the stackmap.
+		if addr != 0 {
+			locals := region{p: p, a: addr, typ: p.findType("runtime.stackmap")}
+			n := locals.Field("n").Int32()       // # of bitmaps
+			nbit := locals.Field("nbit").Int32() // # of bits per bitmap
+			idx, err := f.stackMap.find(off)
+			if err != nil {
+				return nil, fmt.Errorf("cannot read stack map at pc=%#x: %v", pc, err)
+			}
+			if idx < 0 {
+				idx = 0
+			}
+			if idx < int64(n) {
+				bits := locals.Field("bytedata").a.Add(int64(nbit+7) / 8 * idx)
+				base := frame.max.Add(-16).Add(-int64(nbit) * p.proc.PtrSize())
+				// TODO: -16 for amd64. Return address and parent's frame pointer
+				for i := int64(0); i < int64(nbit); i++ {
+					if p.proc.ReadUint8(bits.Add(i/8))>>uint(i&7)&1 != 0 {
+						live[base.Add(i*p.proc.PtrSize())] = true
+					}
 				}
 			}
 		}
 	}
 	// Same for args
 	if x := int(p.rtConstants["_FUNCDATA_ArgsPointerMaps"]); x < len(f.funcdata) {
-		args := region{p: p, a: f.funcdata[x], typ: p.findType("runtime.stackmap")}
-		n := args.Field("n").Int32()       // # of bitmaps
-		nbit := args.Field("nbit").Int32() // # of bits per bitmap
-		idx, err := f.stackMap.find(off)
-		if err != nil {
-			return nil, fmt.Errorf("cannot read stack map at pc=%#x: %v", pc, err)
-		}
-		if idx < 0 {
-			idx = 0
-		}
-		if idx < int64(n) {
-			bits := args.Field("bytedata").a.Add(int64(nbit+7) / 8 * idx)
-			base := frame.max
-			// TODO: add to base for LR archs.
-			for i := int64(0); i < int64(nbit); i++ {
-				if p.proc.ReadUint8(bits.Add(i/8))>>uint(i&7)&1 != 0 {
-					live[base.Add(i*p.proc.PtrSize())] = true
+		addr := f.funcdata[x]
+		if addr != 0 {
+			args := region{p: p, a: addr, typ: p.findType("runtime.stackmap")}
+			n := args.Field("n").Int32()       // # of bitmaps
+			nbit := args.Field("nbit").Int32() // # of bits per bitmap
+			idx, err := f.stackMap.find(off)
+			if err != nil {
+				return nil, fmt.Errorf("cannot read stack map at pc=%#x: %v", pc, err)
+			}
+			if idx < 0 {
+				idx = 0
+			}
+			if idx < int64(n) {
+				bits := args.Field("bytedata").a.Add(int64(nbit+7) / 8 * idx)
+				base := frame.max
+				// TODO: add to base for LR archs.
+				for i := int64(0); i < int64(nbit); i++ {
+					if p.proc.ReadUint8(bits.Add(i/8))>>uint(i&7)&1 != 0 {
+						live[base.Add(i*p.proc.PtrSize())] = true
+					}
 				}
 			}
 		}
diff --git a/internal/gocore/testdata/1.18.zip b/internal/gocore/testdata/1.18.zip
new file mode 100644
index 0000000..105a586
--- /dev/null
+++ b/internal/gocore/testdata/1.18.zip
Binary files differ