fix: supports registers emitted for different platforms.

JVM signal handlers produce different output / formats depending on the
platform. For example an Linux-x64 will of course have different
register names, but they will be formated as four per line, while the
linux-aarch64 will use one register per line.

Links to different `os::print_context` implementations
* https://github.com/openjdk/jdk/blob/master/src/hotspot/os_cpu/linux_x86/os_linux_x86.cpp#L419
* https://github.com/openjdk/jdk/blob/master/src/hotspot/os_cpu/linux_aarch64/os_linux_aarch64.cpp#L341
* https://github.com/openjdk/jdk/blob/master/src/hotspot/os_cpu/bsd_x86/os_bsd_x86.cpp#L601
* https://github.com/openjdk/jdk/blob/master/src/hotspot/os_cpu/bsd_aarch64/os_bsd_aarch64.cpp#L464

Author: bric3

dd-java-agent/agent-crashtracking/src/main/java/datadog/crashtracking/parsers/HotspotCrashLogParser.java

@@ -29,6 +29,18 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+/**
+ * Parser for HotSpot JVM fatal error logs ({@code hs_err_pidNNN.log}).
+ *
+ * <p>The log is parsed using a linear state machine that mirrors the deterministic section order
+ * emitted by {@code VMError::report()} in HotSpot. The section order is fixed for a given platform
+ * but differs across OS/CPU combinations.
+ *
+ * <p>If an early sentinel line is absent (e.g. {@code "Native frames:"} is missing because the JVM
+ * crashed before producing a stack), the state machine will not advance past {@code THREAD} state
+ * and subsequent sections such as {@code siginfo} and registers will be silently skipped. The
+ * resulting {@link datadog.crashtracking.dto.CrashLog} will be marked {@code incomplete}.
+ */
 public final class HotspotCrashLogParser {
   private static final DateTimeFormatter ZONED_DATE_TIME_FORMATTER =
       DateTimeFormatter.ofPattern("EEE MMM ppd HH:mm:ss yyyy zzz", Locale.getDefault());
@@ -69,9 +81,20 @@ public HotspotCrashLogParser() {
           "siginfo:\\s+si_signo:\\s+(\\d+)\\s+\\((\\w+)\\),\\s+si_code:\\s+(\\d+)\\s+\\(([^)]+)\\),\\s+si_addr:\\s+(0x[0-9a-fA-F]+)");
   private static final Pattern DYNAMIC_LIBS_PATH_PARSER =
       Pattern.compile("^(?:0x)?[0-9a-fA-F]+(?:-[0-9a-fA-F]+)?\\s+(?:[^\\s/\\[]+\\s+)*(.*)$");
-  // Matches register entries like: RAX=0x..., R8 =0x..., TRAPNO=0x...
+  // Matches register entries like:
+  // * RAX=0x..., R8 =0x..., TRAPNO=0x... (x86-64)
+  // * R0=0x..., R30=0x... (Linux aarch64)
+  // * x0=0x..., fp=0x..., lr=0x..., sp=0x..., pc=0x... (macOS aarch64)
+  // Note that register formatting varies by platform, the JVM crash handler can emit one or four
+  // per line.
   private static final Pattern REGISTER_ENTRY_PARSER =
-      Pattern.compile("([A-Z0-9]+)\\s*=\\s*(0x[0-9a-fA-F]+)");
+      Pattern.compile("([A-Za-z][A-Za-z0-9]*)\\s*=\\s*(0x[0-9a-fA-F]+)");
+  // Used for the REGISTERS-state exit condition only: the register name must start the line
+  // (after optional whitespace). This prevents lines like "Top of Stack: (sp=0x...)" and
+  // "Instructions: (pc=0x...)" from being mistaken for register entries by REGISTER_ENTRY_PARSER's
+  // find(), which would otherwise match the lowercase "sp"/"pc" tokens embedded in those lines.
+  private static final Pattern REGISTER_LINE_START =
+      Pattern.compile("^\\s*[A-Za-z][A-Za-z0-9]*\\s*=\\s*0x");
 
   private StackFrame parseLine(String line) {
     if (line == null || line.isEmpty()) {
@@ -309,9 +332,8 @@ public CrashLog parse(String uuid, String crashLog) {
           }
           break;
         case REGISTERS:
-          if (!line.isEmpty() && !REGISTER_ENTRY_PARSER.matcher(line).find()) {
-            // non-empty line with no register entries signals end of section; reprocess in
-            // STACKTRACE
+          if (!line.isEmpty() && !REGISTER_LINE_START.matcher(line).find()) {
+            // non-empty line that does not start with a register entry signals end of section
             state = State.STACKTRACE;
           } else {
             final Matcher m = REGISTER_ENTRY_PARSER.matcher(line);

dd-java-agent/agent-crashtracking/src/test/java/datadog/crashtracking/parsers/HotspotCrashLogParserTest.java

@@ -52,6 +52,42 @@ public void testIncompleteParsing() throws Exception {
     assertEquals(0, crashLog.error.stack.frames.length);
   }
 
+  /** macOS aarch64 uses lowercase register names: x0-x28, fp, lr, sp, pc, cpsr */
+  @Test
+  public void testRegisterParsingMacosAarch64() throws Exception {
+    CrashLog crashLog =
+        new HotspotCrashLogParser()
+            .parse(
+                UUID.randomUUID().toString(), readFileAsString("sample-crash-macos-aarch64.txt"));
+
+    assertNotNull(crashLog.experimental, "experimental field should be populated");
+    assertNotNull(crashLog.experimental.ucontext, "ucontext should be populated");
+    assertEquals("0x0000000000000c55", crashLog.experimental.ucontext.get("x0"));
+    assertEquals("0x0000000000000000", crashLog.experimental.ucontext.get("x2"));
+    assertEquals("0x000000016feee210", crashLog.experimental.ucontext.get("fp"));
+    assertEquals("0x0000000116d0c970", crashLog.experimental.ucontext.get("lr"));
+    assertEquals("0x000000016feee0f0", crashLog.experimental.ucontext.get("sp"));
+    assertEquals("0x000000010f8ac794", crashLog.experimental.ucontext.get("pc"));
+    assertEquals("0x0000000060001000", crashLog.experimental.ucontext.get("cpsr"));
+  }
+
+  /** Linux aarch64 uses uppercase register names: R0-R30 */
+  @Test
+  public void testRegisterParsingLinuxAarch64() throws Exception {
+    CrashLog crashLog =
+        new HotspotCrashLogParser()
+            .parse(
+                UUID.randomUUID().toString(), readFileAsString("sample-crash-linux-aarch64.txt"));
+
+    assertNotNull(crashLog.experimental, "experimental field should be populated");
+    assertNotNull(crashLog.experimental.ucontext, "ucontext should be populated");
+    assertEquals("0x0000000000000000", crashLog.experimental.ucontext.get("R0"));
+    assertEquals("0x0000000000000001", crashLog.experimental.ucontext.get("R1"));
+    assertEquals("0x0000ffff9efa168c", crashLog.experimental.ucontext.get("R30"));
+    // "Register to memory mapping:" section must NOT be included
+    assertEquals(31, crashLog.experimental.ucontext.size(), "R0-R30 = 31 registers");
+  }
+
   private String readFileAsString(String resource) throws IOException {
     try (InputStream stream = getClass().getClassLoader().getResourceAsStream(resource)) {
       return new BufferedReader(