From: Arnaldo Carvalho de Melo <acme@kernel.org>
To: Namhyung Kim <namhyung@kernel.org>
Cc: Ingo Molnar <mingo@kernel.org>,
Thomas Gleixner <tglx@linutronix.de>,
James Clark <james.clark@linaro.org>,
Jiri Olsa <jolsa@kernel.org>, Ian Rogers <irogers@google.com>,
Adrian Hunter <adrian.hunter@intel.com>,
Clark Williams <williams@redhat.com>,
linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org,
Arnaldo Carvalho de Melo <acme@redhat.com>
Subject: [PATCH v11 08/19] perf test: Exercise the x86 operand parser
Date: Sun, 22 Nov 2026 18:40:14 -0300 [thread overview]
Message-ID: <20261122214025.16769-9-acme@kernel.org> (raw)
In-Reply-To: <20261122214025.16769-1-acme@kernel.org>
From: Arnaldo Carvalho de Melo <acme@redhat.com>
Add a unit test for x86 operand parsing. The 64-bit absolute disp32
and movabs cases are from the allmodconfig clang build in the preceding
changes. Also check a 32-bit absolute address, an immediate, and
values that should not become absolute addresses. Both objdump
spellings of the movabs instruction must yield the KASAN shadow offset.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
---
tools/perf/tests/Build | 1 +
tools/perf/tests/annotate-ops.c | 172 ++++++++++++++++++++++++++++++++
tools/perf/tests/builtin-test.c | 1 +
tools/perf/tests/tests.h | 1 +
4 files changed, 175 insertions(+)
create mode 100644 tools/perf/tests/annotate-ops.c
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 5eebb2ec5ddefcfd..c7edd8569bbccb06 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -2,6 +2,7 @@
perf-test-y += builtin-test.o
perf-test-y += tests-scripts.o
+perf-test-y += annotate-ops.o
perf-test-y += parse-events.o
perf-test-y += uncore-event-sorting.o
perf-test-y += dso-data.o
diff --git a/tools/perf/tests/annotate-ops.c b/tools/perf/tests/annotate-ops.c
new file mode 100644
index 0000000000000000..766126fc2e2f5e98
--- /dev/null
+++ b/tools/perf/tests/annotate-ops.c
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * The x86 operand parser: what is a memory reference and where it points.
+ *
+ * The data type resolver follows absolute memory operands; an immediate
+ * is not a memory reference.
+ */
+#include <elf.h>
+#include <linux/compiler.h>
+#include <stdlib.h>
+#include <string.h>
+#include "annotate.h"
+#include "debug.h"
+#include "dso.h"
+#include "disasm.h"
+#include "tests.h"
+
+struct op_case {
+ const char *insn;
+ const struct ins_ops *ops;
+ const char *operand;
+ bool mem_ref;
+ int offset;
+};
+
+static struct op_case op_cases[] = {
+ /* 32-bit absolute, and the 64-bit sign extended disp32 both ways */
+ { "mov", &mov_ops, "0x8c73448", true, 0x8c73448 },
+ { "mov", &mov_ops, "0xffffffffff5fc300", true, -0xa03d00 },
+ { "mov", &mov_ops, "-0xa03d00", true, -0xa03d00 },
+ /* An immediate is not a memory reference */
+ { "mov", &mov_ops, "$0x10", false, 0 },
+ /* Zero and values wider than a disp32 are not absolute addresses. */
+ { "mov", &mov_ops, "0x0", false, 0 },
+ { "mov", &mov_ops, "0x100000000", false, 0 },
+};
+
+static int check_operand(const struct arch *arch, const struct op_case *c,
+ struct dso *dso64, struct dso *dso32, struct dso *dsorel)
+{
+ struct disasm_line dl = {
+ .ins = { .name = c->insn, .ops = c->ops },
+ };
+ struct annotated_insn_loc loc;
+ struct annotated_op_loc *op;
+ int ret = 0;
+
+ dl.ops.source.raw = (char *)c->operand;
+
+ if (annotate_get_insn_location(arch, &dl, &loc) < 0)
+ return TEST_FAIL;
+
+ op = &loc.ops[INSN_OP_SOURCE];
+ if (op->mem_ref != c->mem_ref) {
+ pr_debug("'%s %s': mem_ref %d, expected %d\n", c->insn,
+ c->operand, op->mem_ref, c->mem_ref);
+ ret = TEST_FAIL;
+ }
+ if (op->mem_ref && op->offset != c->offset) {
+ pr_debug("'%s %s': offset %#x, expected %#x\n", c->insn,
+ c->operand, op->offset, c->offset);
+ ret = TEST_FAIL;
+ }
+ if (c->mem_ref &&
+ (!annotated_op_loc__is_abs(op, dso64) ||
+ !annotated_op_loc__is_abs(op, dso32) ||
+ annotated_op_loc__abs_addr(op, dso64) != (u64)(s64)c->offset ||
+ annotated_op_loc__abs_addr(op, dso32) != (u32)c->offset)) {
+ pr_debug("'%s %s': wrong absolute address\n", c->insn, c->operand);
+ ret = TEST_FAIL;
+ }
+ /* The same operand in a relocatable object is an addend, not an address */
+ if (c->mem_ref && annotated_op_loc__is_abs(op, dsorel)) {
+ pr_debug("'%s %s': absolute address in a relocatable object\n",
+ c->insn, c->operand);
+ ret = TEST_FAIL;
+ }
+
+ return ret;
+}
+
+struct movabs_case {
+ const char *name;
+ const char *operand;
+ s64 imm;
+};
+
+/* The KASAN shadow offset movabs, as both disassemblers print it */
+static const struct movabs_case movabs_cases[] = {
+ { "movabsq", "$-0x2000040000000000, %r15 # imm = 0xDFFFFC0000000000",
+ -0x2000040000000000LL },
+ { "movabs", "$0xdffffc0000000000,%r15", -0x2000040000000000LL },
+};
+
+static int check_movabs(const struct arch *arch, const struct movabs_case *c)
+{
+ struct disasm_line dl = { .ins = { .name = c->name } };
+ struct annotated_insn_loc loc;
+ int ret = TEST_FAIL;
+
+ dl.ops.raw = strdup(c->operand);
+ if (dl.ops.raw == NULL)
+ return TEST_FAIL;
+
+ dl.ins.ops = ins__find(arch, c->name, &dl);
+ if (dl.ins.ops != &mov_ops || dl.ins.ops->parse(arch, &dl.ops, NULL, &dl) < 0) {
+ pr_debug("'%s %s': not parsed as a mov\n", c->name, c->operand);
+ goto out;
+ }
+
+ /*
+ * get_dwarf_regnum() is a stub returning -1 when perf is built
+ * without libdw, the target register cannot be resolved then.
+ */
+#ifdef HAVE_LIBDW_SUPPORT
+ if (annotate_get_insn_location(arch, &dl, &loc) == 0 &&
+ !loc.ops[INSN_OP_SOURCE].mem_ref && loc.ops[INSN_OP_SOURCE].imm &&
+ loc.ops[INSN_OP_SOURCE].imm_value == c->imm &&
+ loc.ops[INSN_OP_TARGET].reg1 != -1)
+#else
+ if (annotate_get_insn_location(arch, &dl, &loc) == 0 &&
+ !loc.ops[INSN_OP_SOURCE].mem_ref && loc.ops[INSN_OP_SOURCE].imm &&
+ loc.ops[INSN_OP_SOURCE].imm_value == c->imm)
+#endif
+ ret = TEST_OK;
+ else
+ pr_debug("'%s %s': not an immediate to a register\n",
+ c->name, c->operand);
+out:
+ free(dl.ops.source.raw);
+ free(dl.ops.target.raw);
+ free(dl.ops.raw);
+ return ret;
+}
+
+static int test__annotate_ops(struct test_suite *test __maybe_unused,
+ int subtest __maybe_unused)
+{
+ struct e_machine_and_e_flags id = { .e_machine = EM_X86_64, };
+ const struct arch *arch = arch__new_x86(&id, NULL);
+ struct dso *dso64 = dso__new("annotate-ops-64");
+ struct dso *dso32 = dso__new("annotate-ops-32");
+ struct dso *dsorel = dso__new("annotate-ops-rel");
+ size_t i;
+ int ret = 0;
+
+ if (arch == NULL || dso64 == NULL || dso32 == NULL || dsorel == NULL) {
+ dso__put(dso64);
+ dso__put(dso32);
+ dso__put(dsorel);
+ free((void *)arch);
+ return TEST_FAIL;
+ }
+
+ dso__set_is_64_bit(dso64, true);
+ dso__set_is_64_bit(dso32, false);
+ dso__set_rel(dsorel, ET_REL);
+
+ for (i = 0; i < ARRAY_SIZE(op_cases); i++)
+ ret |= check_operand(arch, &op_cases[i], dso64, dso32, dsorel);
+
+ for (i = 0; i < ARRAY_SIZE(movabs_cases); i++)
+ ret |= check_movabs(arch, &movabs_cases[i]);
+
+ dso__put(dso64);
+ dso__put(dso32);
+ dso__put(dsorel);
+ free((void *)arch);
+ return ret;
+}
+
+DEFINE_SUITE("Annotate operand parsing", annotate_ops);
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 01c78ef20b97dec9..a27baf3a819ccf36 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -117,6 +117,7 @@ static struct test_suite *generic_tests[] = {
&suite__openat_syscall_event_on_all_cpus,
&suite__basic_mmap,
&suite__mem,
+ &suite__annotate_ops,
&suite__parse_events,
&suite__uncore_event_sorting,
&suite__expr,
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index af822885890dda73..963cb34acd345153 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -153,6 +153,7 @@ DECLARE_SUITE(sample_parsing);
DECLARE_SUITE(keep_tracking);
DECLARE_SUITE(parse_no_sample_id_all);
DECLARE_SUITE(dwarf_unwind);
+DECLARE_SUITE(annotate_ops);
DECLARE_SUITE(expr);
DECLARE_SUITE(hists_filter);
DECLARE_SUITE(mmap_thread_lookup);
--
2.56.1
next prev parent reply other threads:[~2026-11-22 21:41 UTC|newest]
Thread overview: 20+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-22 21:40 [PATCH v11 00/19] perf coverage: A harness for perf, and the fixes it found Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 01/19] perf build: Link the GTK UI with EXTRA_CFLAGS Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 02/19] perf annotate: Handle absolute addressing in data type profiling Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 03/19] perf annotate: Print the stats after the annotations Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 04/19] perf build: Record the features checked outside FEATURE_TESTS Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 05/19] perf annotate-x86: Record immediates in a 64-bit field Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 06/19] perf annotate-x86: Parse movabs like a mov Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 07/19] perf annotate-data: Count flexible array accesses for the whole struct Arnaldo Carvalho de Melo
2026-11-22 21:40 ` Arnaldo Carvalho de Melo [this message]
2026-11-22 21:40 ` [PATCH v11 09/19] perf test: Exercise DW_OP_addrx global variables Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 10/19] perf test: Exercise the flexible array member path Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 11/19] perf test: Exercise data type resolution from a register Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 12/19] perf test: Exercise the annotate stats output Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 13/19] perf test: Fix the Intel PT virtual LBR check Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 14/19] perf test: Drop samples without an IP in the dlfilter test Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 15/19] perf test: Skip the LBR inline unwinding check when unsupported Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 16/19] perf test: Skip the trace summary BPF tests without kernel BTF Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 17/19] perf test: Avoid online CPUs in the offline stat test Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 18/19] perf scripts: Add a coverage harness for perf Arnaldo Carvalho de Melo
2026-11-22 21:40 ` [PATCH v11 19/19] perf scripts: Add a coverage table Arnaldo Carvalho de Melo
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261122214025.16769-9-acme@kernel.org \
--to=acme@kernel.org \
--cc=acme@redhat.com \
--cc=adrian.hunter@intel.com \
--cc=irogers@google.com \
--cc=james.clark@linaro.org \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=mingo@kernel.org \
--cc=namhyung@kernel.org \
--cc=tglx@linutronix.de \
--cc=williams@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox