libsysprof-analyze: add jitmap symbolizer

This symbolizes using the SysprofCaptureJitmap frames within the capture
document. Currently it only implements the fast path which can avoid a
binary search on the jitmap data.

src/libsysprof-analyze/meson.build

@@ -18,6 +18,7 @@ libsysprof_analyze_public_sources = [
   'sysprof-document-sample.c',
   'sysprof-document-traceable.c',
   'sysprof-elf-symbolizer.c',
+  'sysprof-jitmap-symbolizer.c',
   'sysprof-kallsyms-symbolizer.c',
   'sysprof-multi-symbolizer.c',
   'sysprof-no-symbolizer.c',
@@ -63,6 +64,7 @@ libsysprof_analyze_public_headers = [
   'sysprof-document-sample.h',
   'sysprof-document-traceable.h',
   'sysprof-elf-symbolizer.h',
+  'sysprof-jitmap-symbolizer.h',
   'sysprof-kallsyms-symbolizer.h',
   'sysprof-mount.h',
   'sysprof-multi-symbolizer.h',

src/libsysprof-analyze/sysprof-analyze.h

@@ -44,6 +44,7 @@ G_BEGIN_DECLS
 # include "sysprof-document-sample.h"
 # include "sysprof-document-traceable.h"
 # include "sysprof-elf-symbolizer.h"
+# include "sysprof-jitmap-symbolizer.h"
 # include "sysprof-kallsyms-symbolizer.h"
 # include "sysprof-mount.h"
 # include "sysprof-multi-symbolizer.h"

src/libsysprof-analyze/sysprof-document-loader.c

@@ -27,6 +27,7 @@
 #include "sysprof-document-loader.h"
 #include "sysprof-document-private.h"
 #include "sysprof-elf-symbolizer.h"
+#include "sysprof-jitmap-symbolizer.h"
 #include "sysprof-kallsyms-symbolizer.h"
 #include "sysprof-multi-symbolizer.h"
 
@@ -150,6 +151,7 @@ set_default_symbolizer (SysprofDocumentLoader *self)
   sysprof_multi_symbolizer_take (multi, sysprof_bundled_symbolizer_new ());
   sysprof_multi_symbolizer_take (multi, sysprof_kallsyms_symbolizer_new ());
   sysprof_multi_symbolizer_take (multi, sysprof_elf_symbolizer_new ());
+  sysprof_multi_symbolizer_take (multi, sysprof_jitmap_symbolizer_new ());
   self->symbolizer = SYSPROF_SYMBOLIZER (g_steal_pointer (&multi));
 }
 

src/libsysprof-analyze/sysprof-jitmap-symbolizer.c

@@ -0,0 +1,238 @@
+/* sysprof-jitmap-symbolizer.c
+ *
+ * Copyright 2023 Christian Hergert <chergert@redhat.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "config.h"
+
+#include "sysprof-document-jitmap.h"
+#include "sysprof-document-private.h"
+#include "sysprof-jitmap-symbolizer.h"
+#include "sysprof-symbol-private.h"
+#include "sysprof-symbolizer-private.h"
+
+typedef struct _Jitmap
+{
+  SysprofAddress address;
+  GRefString *name;
+} Jitmap;
+
+struct _SysprofJitmapSymbolizer
+{
+  SysprofSymbolizer parent_instance;
+  GArray *jitmaps;
+};
+
+struct _SysprofJitmapSymbolizerClass
+{
+  SysprofSymbolizerClass parent_class;
+};
+
+G_DEFINE_FINAL_TYPE (SysprofJitmapSymbolizer, sysprof_jitmap_symbolizer, SYSPROF_TYPE_SYMBOLIZER)
+
+typedef struct
+{
+  SysprofDocument *document;
+  GListModel *model;
+} Prepare;
+
+static void
+prepare_free (gpointer data)
+{
+  Prepare *prepare = data;
+
+  g_clear_object (&prepare->model);
+  g_clear_object (&prepare->document);
+  g_free (prepare);
+}
+
+static void
+jitmap_clear (gpointer data)
+{
+  Jitmap *j = data;
+  g_clear_pointer (&j->name, g_ref_string_release);
+}
+
+static int
+sort_by_address (gconstpointer a,
+                 gconstpointer b)
+{
+  const Jitmap *jitmap_a = a;
+  const Jitmap *jitmap_b = b;
+
+  if (jitmap_a->address < jitmap_b->address)
+    return -1;
+  else if (jitmap_a->address > jitmap_b->address)
+    return 1;
+  else
+    return 0;
+}
+
+static void
+sysprof_jitmap_symbolizer_prepare_worker (GTask        *task,
+                                          gpointer      source_object,
+                                          gpointer      task_data,
+                                          GCancellable *cancellable)
+{
+  SysprofJitmapSymbolizer *self = source_object;
+  Prepare *prepare = task_data;
+  guint n_jitmaps;
+
+  g_assert (G_IS_TASK (task));
+  g_assert (SYSPROF_IS_JITMAP_SYMBOLIZER (self));
+  g_assert (prepare != NULL);
+  g_assert (SYSPROF_IS_DOCUMENT (prepare->document));
+  g_assert (G_IS_LIST_MODEL (prepare->model));
+  g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+  n_jitmaps = g_list_model_get_n_items (prepare->model);
+
+  for (guint i = 0; i < n_jitmaps; i++)
+    {
+      g_autoptr(SysprofDocumentJitmap) jitmap = g_list_model_get_item (prepare->model, i);
+      guint size = sysprof_document_jitmap_get_size (jitmap);
+
+      for (guint j = 0; j < size; j++)
+        {
+          const char *name;
+          Jitmap map;
+
+          if (!(name = sysprof_document_jitmap_get_mapping (jitmap, j, &map.address)))
+            continue;
+
+          map.name = _sysprof_document_ref_string (prepare->document, name);
+          g_array_append_val (self->jitmaps, map);
+        }
+    }
+
+  g_array_sort (self->jitmaps, sort_by_address);
+
+  g_task_return_boolean (task, TRUE);
+}
+
+static void
+sysprof_jitmap_symbolizer_prepare_async (SysprofSymbolizer   *symbolizer,
+                                         SysprofDocument     *document,
+                                         GCancellable        *cancellable,
+                                         GAsyncReadyCallback  callback,
+                                         gpointer             user_data)
+{
+  SysprofJitmapSymbolizer *self = (SysprofJitmapSymbolizer *)symbolizer;
+  g_autoptr(GTask) task = NULL;
+  Prepare *prepare;
+
+  g_assert (SYSPROF_IS_JITMAP_SYMBOLIZER (self));
+  g_assert (SYSPROF_IS_DOCUMENT (document));
+  g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+  prepare = g_new0 (Prepare, 1);
+  prepare->document = g_object_ref (document);
+  prepare->model = sysprof_document_list_jitmaps (document);
+
+  task = g_task_new (self, cancellable, callback, user_data);
+  g_task_set_source_tag (task, sysprof_jitmap_symbolizer_prepare_async);
+  g_task_set_task_data (task, prepare, prepare_free);
+  g_task_run_in_thread (task, sysprof_jitmap_symbolizer_prepare_worker);
+}
+
+static gboolean
+sysprof_jitmap_symbolizer_prepare_finish (SysprofSymbolizer  *symbolizer,
+                                          GAsyncResult       *result,
+                                          GError            **error)
+{
+  g_assert (SYSPROF_IS_JITMAP_SYMBOLIZER (symbolizer));
+  g_assert (G_IS_TASK (result));
+  g_assert (g_task_is_valid (result, symbolizer));
+
+  return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static SysprofSymbol *
+sysprof_jitmap_symbolizer_symbolize (SysprofSymbolizer        *symbolizer,
+                                     SysprofStrings           *strings,
+                                     const SysprofProcessInfo *process_info,
+                                     SysprofAddressContext     context,
+                                     SysprofAddress            address)
+{
+  SysprofJitmapSymbolizer *self = (SysprofJitmapSymbolizer *)symbolizer;
+  guint guess = (address & 0xFFFF) - 1;
+
+  if (context != SYSPROF_ADDRESS_CONTEXT_NONE &&
+      context != SYSPROF_ADDRESS_CONTEXT_USER)
+    return NULL;
+
+  if ((address & 0xFFFFFFFF00000000) != 0xE000000000000000)
+    return NULL;
+
+  /* Jitmap addresses generally start at 1 and work their way up
+   * monotonically (after masking off the high 0xE...............
+   * bits). So we can try for a fast index lookup to skip any sort
+   * of searching in the well behaved case.
+   */
+  if G_LIKELY (guess < self->jitmaps->len)
+    {
+      const Jitmap *j = &g_array_index (self->jitmaps, Jitmap, guess);
+
+      if G_LIKELY (j->address == address)
+        return _sysprof_symbol_new (g_ref_string_acquire (j->name),
+                                    NULL,
+                                    NULL,
+                                    j->address,
+                                    j->address + 1);
+    }
+
+  /* TODO: Binary search for match */
+
+  return NULL;
+}
+
+static void
+sysprof_jitmap_symbolizer_finalize (GObject *object)
+{
+  SysprofJitmapSymbolizer *self = (SysprofJitmapSymbolizer *)object;
+
+  g_clear_pointer (&self->jitmaps, g_array_unref);
+
+  G_OBJECT_CLASS (sysprof_jitmap_symbolizer_parent_class)->finalize (object);
+}
+
+static void
+sysprof_jitmap_symbolizer_class_init (SysprofJitmapSymbolizerClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  SysprofSymbolizerClass *symbolizer_class = SYSPROF_SYMBOLIZER_CLASS (klass);
+
+  object_class->finalize = sysprof_jitmap_symbolizer_finalize;
+
+  symbolizer_class->prepare_async = sysprof_jitmap_symbolizer_prepare_async;
+  symbolizer_class->prepare_finish = sysprof_jitmap_symbolizer_prepare_finish;
+  symbolizer_class->symbolize = sysprof_jitmap_symbolizer_symbolize;
+}
+
+static void
+sysprof_jitmap_symbolizer_init (SysprofJitmapSymbolizer *self)
+{
+  self->jitmaps = g_array_new (FALSE, FALSE, sizeof (Jitmap));
+  g_array_set_clear_func (self->jitmaps, jitmap_clear);
+}
+
+SysprofSymbolizer *
+sysprof_jitmap_symbolizer_new (void)
+{
+  return g_object_new (SYSPROF_TYPE_JITMAP_SYMBOLIZER, NULL);
+}

src/libsysprof-analyze/sysprof-jitmap-symbolizer.h

@@ -0,0 +1,42 @@
+/* sysprof-jitmap-symbolizer.h
+ *
+ * Copyright 2023 Christian Hergert <chergert@redhat.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include "sysprof-symbolizer.h"
+
+G_BEGIN_DECLS
+
+#define SYSPROF_TYPE_JITMAP_SYMBOLIZER         (sysprof_jitmap_symbolizer_get_type())
+#define SYSPROF_IS_JITMAP_SYMBOLIZER(obj)      G_TYPE_CHECK_INSTANCE_TYPE(obj, SYSPROF_TYPE_JITMAP_SYMBOLIZER)
+#define SYSPROF_JITMAP_SYMBOLIZER(obj)         G_TYPE_CHECK_INSTANCE_CAST(obj, SYSPROF_TYPE_JITMAP_SYMBOLIZER, SysprofJitmapSymbolizer)
+#define SYSPROF_JITMAP_SYMBOLIZER_CLASS(klass) G_TYPE_CHECK_CLASS_CAST(klass, SYSPROF_TYPE_JITMAP_SYMBOLIZER, SysprofJitmapSymbolizerClass)
+
+typedef struct _SysprofJitmapSymbolizer      SysprofJitmapSymbolizer;
+typedef struct _SysprofJitmapSymbolizerClass SysprofJitmapSymbolizerClass;
+
+SYSPROF_AVAILABLE_IN_ALL
+GType              sysprof_jitmap_symbolizer_get_type (void) G_GNUC_CONST;
+SYSPROF_AVAILABLE_IN_ALL
+SysprofSymbolizer *sysprof_jitmap_symbolizer_new      (void);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (SysprofJitmapSymbolizer, g_object_unref)
+
+G_END_DECLS

src/libsysprof-analyze/tests/test-symbolize.c

@@ -132,8 +132,9 @@ main (int argc,
     {
       g_autoptr(SysprofMultiSymbolizer) multi = sysprof_multi_symbolizer_new ();
 
-      sysprof_multi_symbolizer_take (multi, sysprof_elf_symbolizer_new ());
       sysprof_multi_symbolizer_take (multi, sysprof_kallsyms_symbolizer_new ());
+      sysprof_multi_symbolizer_take (multi, sysprof_elf_symbolizer_new ());
+      sysprof_multi_symbolizer_take (multi, sysprof_jitmap_symbolizer_new ());
 
       sysprof_document_loader_set_symbolizer (loader, SYSPROF_SYMBOLIZER (multi));
     }