@@ -63,3 +63,47 @@ func evaluateStubAnswerAMD64(res e.Expression, memBase uint64) (uint64, error) {
 	}
 	return 0, fmt.Errorf("not found %s", res.DebugString())
 }
+
+// extractTLSOffsetFromCodeAMD64 extracts the TLS offset by analyzing x86_64 assembly code.
+// It looks for MOV instructions with FS segment prefix (e.g., MOV rax, FS:[offset]).
+func extractTLSOffsetFromCodeAMD64(code []byte, baseAddr uint64) (int64, error) {
+	it := amd.NewInterpreterWithCode(code)
+	it.CodeAddress = e.Imm(baseAddr)
+
+	offset := e.NewImmediateCapture("tls_offset")
+	expected := e.MemWithSegment8(x86asm.FS, offset)
+
+	for {
+		op, err := it.Step()
+		if err != nil {
+			break
+		}
+
+		if op.Op != x86asm.MOV {
+			continue
+		}
+
+		// Check if the source argument (Args[1]) uses FS segment
+		mem, ok := op.Args[1].(x86asm.Mem)
+		if !ok || mem.Segment != x86asm.FS {
+			continue
+		}
+
+		// Get the destination register's expression
+		dst, ok := op.Args[0].(x86asm.Reg)
+		if !ok {
+			continue
+		}
+
+		actual := it.Regs.GetX86(dst)
+		if actual.Match(expected) {
+			capturedValue := offset.CapturedValue()
+			signedOffset := int64(int32(capturedValue))
+			if (signedOffset < 0 && signedOffset > -4096) || (signedOffset > 0 && signedOffset < 4096) {
+				return signedOffset, nil
+			}
+		}
+	}
+
+	return 0, fmt.Errorf("could not find FS-relative MOV instruction")
+}
@@ -4,8 +4,11 @@
 package python // import "go.opentelemetry.io/ebpf-profiler/interpreter/python"
 
 import (
+	"fmt"
+
 	ah "go.opentelemetry.io/ebpf-profiler/armhelpers"
 	"go.opentelemetry.io/ebpf-profiler/libpf"
+	"go.opentelemetry.io/ebpf-profiler/libpf/pfelf"
 	aa "golang.org/x/arch/arm64/arm64asm"
 )
 
@@ -100,3 +103,98 @@ func decodeStubArgumentARM64(code []byte,
 
 	return libpf.SymbolValueInvalid
 }
+
+// extractTLSOffsetFromCodeARM64 extracts the TLS offset by analyzing ARM64 assembly code.
+// It looks for the pattern: MRS Xn, TPIDR_EL0 followed by ADD Xn, Xn, #offset or LDR [Xn, #offset].
+func extractTLSOffsetFromCodeARM64(code []byte, baseAddr uint64, visited map[uint64]bool, depth int, ef *pfelf.File) (int64, error) {
+	// Prevent infinite recursion
+	const maxDepth = 5
+	if depth > maxDepth {
+		return 0, fmt.Errorf("max recursion depth exceeded")
+	}
+
+	if visited[baseAddr] {
+		return 0, fmt.Errorf("already visited address 0x%x", baseAddr)
+	}
+	visited[baseAddr] = true
+
+	foundMRS := false
+	var tpReg int
+
+	for offs := 0; offs < len(code)-4; offs += 4 {
+		inst, err := aa.Decode(code[offs:])
+		if err != nil {
+			continue
+		}
+
+		// Check for MRS Xn, TPIDR_EL0 (system register S3_3_C13_C0_2)
+		if inst.Op == aa.MRS && inst.Args[1].String() == "S3_3_C13_C0_2" {
+			reg, ok := ah.Xreg2num(inst.Args[0])
+			if !ok {
+				continue
+			}
+			tpReg = reg
+			foundMRS = true
+
+			// Look ahead for ADD or LDR using this register
+			for j := offs + 4; j < len(code)-4 && j < offs+64; j += 4 {
+				nextInst, err := aa.Decode(code[j:])
+				if err != nil {
+					continue
+				}
+
+				// Check for ADD Xd, Xn, #imm
+				if nextInst.Op == aa.ADD {
+					destReg, destOk := ah.Xreg2num(nextInst.Args[0])
+					srcReg, srcOk := ah.Xreg2num(nextInst.Args[1])
+					imm, immOk := ah.DecodeImmediate(nextInst.Args[2])
+
+					if destOk && srcOk && immOk && srcReg == tpReg {
+						if imm > 0 && imm < 0x1000 {
+							return int64(imm), nil
+						}
+						// Track the new register holding TP+offset
+						tpReg = destReg
+					}
+				}
+
+				// Check for LDR Xm, [Xn, #imm]
+				if nextInst.Op == aa.LDR {
+					// Args[1] is MemImmediate
+					if mem, ok := nextInst.Args[1].(aa.MemImmediate); ok {
+						baseReg, regOk := ah.Xreg2num(mem.Base)
+						imm, immOk := ah.DecodeImmediate(mem)
+
+						if regOk && immOk && baseReg == tpReg {
+							if imm > 0 && imm < 0x1000 {
+								return int64(imm), nil
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Check for unconditional branch
+		if inst.Op == aa.B {
+			if pcrel, ok := inst.Args[0].(aa.PCRel); ok {
+				targetAddr := int64(baseAddr) + int64(offs) + int64(pcrel)
+
+				if targetAddr > 0 && targetAddr < 0x100000000 && !visited[uint64(targetAddr)] {
+					targetCode := make([]byte, 256)
+					err := ef.GetRemoteMemory().Read(libpf.Address(targetAddr), targetCode)
+					if err == nil {
+						if result, err := extractTLSOffsetFromCodeARM64(targetCode, uint64(targetAddr), visited, depth+1, ef); err == nil {
+							return result, nil
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if !foundMRS {
+		return 0, fmt.Errorf("could not find MRS TPIDR_EL0 instruction")
+	}
+	return 0, fmt.Errorf("found MRS TPIDR_EL0 but no matching ADD/LDR with TLS offset")
+}