Merge pull request #69 from parca-dev/unit-test

Unit test for register zero and rsi/esi bugs

Remove old mappings before adding new ones to avoid map collisions.

Author: gnurizen

interpreter/luajit/luajit.go

@@ -13,6 +13,7 @@ package luajit // import "go.opentelemetry.io/ebpf-profiler/interpreter/luajit"
 
 import (
 	"errors"
+	"fmt"
 	"path"
 	"strings"
 	"sync"
@@ -256,22 +257,26 @@ func (l *luajitInstance) synchronizeMappings(ebpf interpreter.EbpfHandler, pid l
 		l.jitRegions[*m] = cycle
 	}
 
-	// Add new ones and remove garbage ones
+	// Remove old ones
 	for m, c := range l.jitRegions {
 		k := regionKey{start: m.Vaddr, end: m.Vaddr + m.Length}
 		if c != cycle {
 			for _, prefix := range l.prefixes[k] {
 				if err := ebpf.DeletePidInterpreterMapping(pid, prefix); err != nil {
-					return err
+					return errors.Join(err, fmt.Errorf("failed to delete prefix %v", prefix))
 				}
 			}
 			delete(l.jitRegions, m)
 			delete(l.prefixes, k)
-		} else {
-			if _, ok := l.prefixes[k]; !ok {
-				if err := l.addJITRegion(ebpf, pid, m.Vaddr, m.Vaddr+m.Length); err != nil {
-					return err
-				}
+		}
+	}
+
+	// Add new ones
+	for m := range l.jitRegions {
+		k := regionKey{start: m.Vaddr, end: m.Vaddr + m.Length}
+		if _, ok := l.prefixes[k]; !ok {
+			if err := l.addJITRegion(ebpf, pid, m.Vaddr, m.Vaddr+m.Length); err != nil {
+				return errors.Join(err, fmt.Errorf("failed to add JIT region %v", m))
 			}
 		}
 	}

interpreter/luajit/offsets_test.go

@@ -164,6 +164,45 @@ func getLibFromImage(t *testing.T, name, platform, fullPath, target string) {
 	require.NoError(t, err)
 }
 
+func TestX86LuaClose(t *testing.T) {
+	testdata := []struct {
+		name          string
+		glRefExpected uint64
+		curLExpected  uint64
+		code          []byte
+	}{
+		{
+			name:          "size-optimized-register-zero",
+			glRefExpected: 0x10,
+			curLExpected:  0x158,
+			code: []byte{
+				0x41, 0x55, //                               pushq   %r13
+				0x4c, 0x8d, 0x2d, 0x3f, 0xd4, 0xff, 0xff, // leaq    -0x2bc1(%rip), %r13
+				0x41, 0x54, //                               pushq   %r12
+				0x41, 0xbc, 0x0a, 0x00, 0x00, 0x00, //       movl    $0xa, %r12d
+				0x55,                   //                   pushq   %rbp
+				0x53,                   //                   pushq   %rbx
+				0x51,                   //                   pushq   %rcx
+				0x48, 0x8b, 0x5f, 0x10, //                   movq    0x10(%rdi), %rbx
+				0x48, 0x8b, 0xab, 0xc8, 0x00, 0x00, 0x00, // movq    0xc8(%rbx), %rbp
+				0x48, 0x89, 0xef, // movq    %rbp, %rdi
+				0xe8, 0x6e, 0x17, 0x00, 0x00, // callq   0x175f0 <luaJIT_profile_stop>
+				0x31, 0xf6, // xorl    %esi, %esi
+				0x48, 0x89, 0xef, // movq    %rbp, %rdi
+				0x48, 0x89, 0xb3, 0x58, 0x01, 0x00, 0x00, // movq    %rsi, 0x158(%rbx)
+			},
+		},
+	}
+
+	for _, test := range testdata {
+		x := x86Extractor{}
+		glref, curL, err := x.findOffsetsFromLuaClose(test.code)
+		require.NoError(t, err)
+		require.Equal(t, test.glRefExpected, glref)
+		require.Equal(t, test.curLExpected, curL)
+	}
+}
+
 // spot testing
 func TestFiles(t *testing.T) {
 	files, err := os.ReadDir("./testdata")

tools/dis2go.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+
+import re
+import sys
+
+def transform_disassembly(lines):
+    """
+    Transform llvm-objdump disassembly to a Go byte array literal.
+    Written by Claude.
+
+    This function:
+    1. Removes offset prefixes (like "15e5b:")
+    2. Adds "0x" prefix to each byte and comma separators
+    3. Comments out the disassembly parts with "//"
+
+    Args:
+        lines: A list of input lines to transform
+
+    Returns:
+        A list of transformed lines
+    """
+    result = []
+
+    for line in lines:
+        # Skip empty lines
+        if not line.strip():
+            continue
+
+        # Extract the parts using regex
+        # Match the address prefix, then bytes, then the assembly instruction
+        match = re.match(r'^\s*[0-9a-f]+:\s+([0-9a-f\s]+)(.+)$', line)
+        if match:
+            # Get the machine code bytes
+            bytes_str = match.group(1).strip()
+            # Get the assembly instruction
+            asm_instr = match.group(2).strip()
+
+            # Split the bytes and add 0x prefix and commas
+            bytes_list = [f"0x{b}" for b in bytes_str.split()]
+            formatted_bytes = ", ".join(bytes_list) + ","
+
+            # Pad with spaces to align comments
+            pad_length = max(40 - len(formatted_bytes), 1)
+            padding = " " * pad_length
+
+            # Create the Go byte array line with commented assembly
+            result.append(f"{formatted_bytes}{padding}// {asm_instr}")
+        else:
+            # If the line doesn't match our expected format, keep it as a comment
+            result.append(f"// {line.strip()}")
+
+    return result
+
+def main():
+    # Read from stdin
+    lines = sys.stdin.readlines()
+
+    # Transform the lines
+    transformed_lines = transform_disassembly(lines)
+
+    # Write to stdout
+    sys.stdout.write("\n".join(transformed_lines))
+    sys.stdout.write("\n")  # Add a final newline
+
+if __name__ == "__main__":
+    main()