Perf tools: Support eGPRs/SSP/SIMD registers sampling
Subsystems (2)
v9 cover Perf tools: Support eGPRs/SSP/SIMD registers sampling
Patch layout:
- Patches 1-2: Fix two bugs in DWARF register bounds checking and event attribute printing/swapping.
- Patches 3-4: Sync tools and perf headers with the kernel sources.
- Patches 5-8: Add SIMD/eGPR/SSP sampling and dump support.
- Patches 9-10: Add unit tests for SIMD/eGPR/SSP sampling.
Changes since v8:
- Patch 01/10: Fix incorrect DWARF register bounds checking.
- Patch 02/10: Add missing event attribute printing and swapping support (Sashiko).
- Patch 07/10: Remove dead code ([idx++]) in SIMD register dumping (Sashiko).
- Patch 08/10: Restore the original x86 libdw_frame_nregs value (17), as libdw still lacks x86 SIMD/eGPR support (Ian).
- Patch 09/10: Add x86 eGPR/SSP sampling unit tests (Ian).
- Patch 10/10: Add x86 SIMD register sampling unit tests (Ian).
Changes since v7:
- Address Sashiko's comments including,
* documents are not update availably; SIMD registers bitmask may be overwritten by shorter mask; u16 type in sample meta-data break the cross-endian conversion, etc.
- Add SIMD/eGPRs/SSP support in dwarf-regs (Ian).
- Misc enhancements.
Changes since v6:
- Address Ian's comments including,
* Add more comments for newly added register indexes (patch 1/4).
* Several minor enhancements in patch 4/4.
- Limit dwarf minimal regs to legacy GPRs (excluding APX eGPRs) (patch 2/4).
Changes since v5:
- Split the sampling support for eGPRs/SSP registers and SIMD registers into 2 patches.
- Address Ian's comments including,
* Convert the architecture dependent functions into regular architectural independent functions, like whatperf_reg_name() does.
* Refine the functions name to represent what the functions really do.
* Add comments for some key functions arguments.
* Misc enhancements.
This patch-set adds sampling support for x86 eGPRs/SSP/SIMD registers in perf tools base on the corresponding sampling support for eGPRs/SSP/SIMD registers in kernel[1]. In versions before v6, these perf-tools patches are integrated as a whole patch-set with the kernel patches, but it's split and posted to an independent perf-tools patch-set for convenient review.
History:
v8: https://lore.kernel.org/all/[email protected]/
v7: https://lore.kernel.org/all/[email protected]/
v6: https://lore.kernel.org/all/[email protected]/
v5: https://lore.kernel.org/all/[email protected]/
v4: https://lore.kernel.org/all/[email protected]/
v3: https://lore.kernel.org/lkml/[email protected]/
v2: https://lore.kernel.org/lkml/[email protected]/
v1: https://lore.kernel.org/lkml/[email protected]/
Ref:
[1] Kernel patches of supporting eGPRs/SSP/SIMD registers sampling:
https://lore.kernel.org/all/[email protected]/
Dapeng Mi (10):
perf dwarf-regs: Fix DWARF register index bounds check perf util: Add missed fields in _attr__fprintf() and __attr_swap() tools headers: Sync x86 headers with kernel sources
perf headers: Sync perf_event.h/perf_regs.h with the kernel headers perf regs: Support x86 eGPRs/SSP sampling
perf regs: Support x86 SIMD registers sampling
perf regs: Enable dumping of SIMD registers
perf dwarf-regs: Add SIMD/eGPRs support for x86 DWARF registers perf tests: Add x86 eGPRs/SSP registers sampling test perf tests: Add SIMD registers sampling test
tools/arch/x86/include/asm/msr-index.h | 7 + tools/arch/x86/include/uapi/asm/perf_regs.h | 53 +++ tools/include/uapi/linux/perf_event.h | 49 ++- tools/perf/Documentation/perf-record.txt | 10 +- tools/perf/builtin-script.c | 93 +++- tools/perf/tests/shell/record.sh | 257 +++++++++++ .../util/dwarf-regs-arch/dwarf-regs-csky.c | 2 +- .../util/dwarf-regs-arch/dwarf-regs-powerpc.c | 2 +- .../util/dwarf-regs-arch/dwarf-regs-s390.c | 2 +- .../util/dwarf-regs-arch/dwarf-regs-x86.c | 140 +++++- tools/perf/util/dwarf-regs.c | 9 +- tools/perf/util/evsel.c | 104 ++++- tools/perf/util/header.c | 3 +- tools/perf/util/include/dwarf-regs.h | 7 +- tools/perf/util/parse-regs-options.c | 186 +++++++- .../perf/util/perf-regs-arch/perf_regs_x86.c | 416 +++++++++++++++++- tools/perf/util/perf_event_attr_fprintf.c | 13 + tools/perf/util/perf_regs.c | 84 +++- tools/perf/util/perf_regs.h | 21 +- tools/perf/util/record.h | 7 + tools/perf/util/sample.h | 5 + .../scripting-engines/trace-event-python.c | 127 +++++- tools/perf/util/session.c | 112 ++++- tools/perf/util/synthetic-events.c | 38 ++ tools/perf/util/unwind-libdw.c | 6 +- 25 files changed, 1643 insertions(+), 110 deletions(-)
base-commit: ca0e19074bd6afcb9c7b23aa474ca17238cdb241
Signature · 1 line
2.34.1
PATCH v9 1/10 perf dwarf-regs: Fix DWARF register index bounds check
Tighten bounds validation in __get_dwarf_regnum_for_perf_regnum_xxx() helpers by changing perf_regnum > ARRAY_SIZE() to perf_regnum >= ARRAY_SIZE().
This fixes an off-by-one condition where perf_regnum == ARRAY_SIZE() could pass validation and cause out-of-bounds access for dwarf_xxx_regnums[].
--- tools/perf/util/dwarf-regs-arch/dwarf-regs-csky.c | 2 +- tools/perf/util/dwarf-regs-arch/dwarf-regs-powerpc.c | 2 +- tools/perf/util/dwarf-regs-arch/dwarf-regs-s390.c | 2 +- tools/perf/util/dwarf-regs-arch/dwarf-regs-x86.c | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-)
tools/perf/util/dwarf-regs-arch/dwarf-regs-csky.c +1 -1
@@ -118,7 +118,7 @@ int __get_dwarf_regnum_for_perf_regnum_csky(int perf_regnum, unsigned int flags)if (flags &EF_CSKY_ABIV2 ) idx++; -if (perf_regnum <0 || perf_regnum > (int )ARRAY_SIZE (dwarf_csky_regnums) || +if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_csky_regnums) || dwarf_csky_regnums[perf_regnum][idx] ==0 )return -ENOENT ;
tools/perf/util/dwarf-regs-arch/dwarf-regs-powerpc.c +1 -1
@@ -128,7 +128,7 @@ int __get_dwarf_regnum_for_perf_regnum_powerpc(int perf_regnum)if (perf_regnum ==0 )return 0 ; -if (perf_regnum <0 || perf_regnum > (int )ARRAY_SIZE (dwarf_powerpc_regnums) || +if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_powerpc_regnums) || dwarf_powerpc_regnums[perf_regnum] ==0 )return -ENOENT ;
tools/perf/util/dwarf-regs-arch/dwarf-regs-s390.c +1 -1
@@ -45,7 +45,7 @@ int __get_dwarf_regnum_for_perf_regnum_s390(int perf_regnum)if (perf_regnum ==0 )return 0 ; -if (perf_regnum <0 || perf_regnum > (int )ARRAY_SIZE (dwarf_s390_regnums) || +if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_s390_regnums) || dwarf_s390_regnums[perf_regnum] ==0 )return -ENOENT ;
tools/perf/util/dwarf-regs-arch/dwarf-regs-x86.c +2 -2
@@ -197,7 +197,7 @@ int __get_dwarf_regnum_for_perf_regnum_i386(int perf_regnum)if (perf_regnum ==0 )return 0 ; -if (perf_regnum <0 || perf_regnum > (int )ARRAY_SIZE (dwarf_i386_regnums) || +if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_i386_regnums) || dwarf_i386_regnums[perf_regnum] ==0 )return -ENOENT ;
@@ -252,7 +252,7 @@ int __get_dwarf_regnum_for_perf_regnum_x86_64(int perf_regnum)if (perf_regnum ==0 )return 0 ; -if (perf_regnum <0 || perf_regnum > (int )ARRAY_SIZE (dwarf_x86_64_regnums) || +if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_x86_64_regnums) || dwarf_x86_64_regnums[perf_regnum] ==0 )return -ENOENT ;
Signature · 1 line
2.34.1
PATCH v9 2/10 perf util: Add missed fields in _attr__fprintf() and __attr_swap()
In reply to Dapeng MiSome new introduced perf_event_attr fields, like config3 and config4, are forgotten to add into perf_event_attr__fprintf() and perf_event__attr_swap() helpers. Add these missed fields into these 2 helpers.
The aux_action is an exception. aux_action aliases bitfields (e.g. aux_start_paused) in a union. Bitfields and plain u32 fields follow different endian rules, so both views cannot be swapped correctly at the same time. Leave aux_action unswapped until the ABI is represented in a byte-order-safe form.
--- tools/perf/util/perf_event_attr_fprintf.c | 4 ++++ tools/perf/util/session.c | 10 ++++++++++ 2 files changed, 14 insertions(+)
tools/perf/util/perf_event_attr_fprintf.c +4 -0
@@ -405,6 +405,10 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,PRINT_ATTRf_bf (aux_pause, p_unsigned);PRINT_ATTRf_bf (aux_resume, p_unsigned); } +if (attr_size >= offsetof(struct perf_event_attr , config4)) +PRINT_ATTRf (config3, p_hex); +if (attr_size > offsetof(struct perf_event_attr , config4)) +PRINT_ATTRf (config4, p_hex);return ret; }
tools/perf/util/session.c +10 -0
@@ -629,6 +629,16 @@ do { \bswap_field_32 (aux_watermark);bswap_field_16 (sample_max_stack);bswap_field_32 (aux_sample_size); +/* +* aux_action aliases bitfields (e.g. aux_start_paused) in a union. +* Bitfields and plain u32 fields follow different endian rules, so +* both views cannot be swapped correctly at the same time. +* Leave aux_action unswapped until the ABI is represented in a +* byte-order-safe form. +*/ +bswap_field_64 (sig_data); +bswap_field_64 (config3); +bswap_field_64 (config4);/* * After read_format are bitfields. Check read_format because
Signature · 1 line
2.34.1
PATCH v9 3/10 tools headers: Sync x86 headers with kernel sources
In reply to Dapeng MiSync newly introduced ARCH_PEBS_VECR_xxx macros from kernel.
--- tools/arch/x86/include/asm/msr-index.h | 7 +++++++ 1 file changed, 7 insertions(+)
tools/arch/x86/include/asm/msr-index.h +7 -0
@@ -350,6 +350,13 @@#define ARCH_PEBS_LBR_SHIFT 40#define ARCH_PEBS_LBR (0x3ull << ARCH_PEBS_LBR_SHIFT)#define ARCH_PEBS_VECR_XMM BIT_ULL(49) +#define ARCH_PEBS_VECR_YMMH BIT_ULL(50) +#define ARCH_PEBS_VECR_EGPRS BIT_ULL(51) +#define ARCH_PEBS_VECR_OPMASK BIT_ULL(53) +#define ARCH_PEBS_VECR_ZMMH BIT_ULL(54) +#define ARCH_PEBS_VECR_H16ZMM BIT_ULL(55) +#define ARCH_PEBS_VECR_EXT_SHIFT 49 +#define ARCH_PEBS_VECR_EXT (0x7full << ARCH_PEBS_VECR_EXT_SHIFT)#define ARCH_PEBS_GPR BIT_ULL(61)#define ARCH_PEBS_AUX BIT_ULL(62)#define ARCH_PEBS_EN BIT_ULL(63)
Signature · 1 line
2.34.1
[email protected]
AI reviewRe: [Patch v9 03/10] tools headers: Sync x86 headers with kernel sources
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Low] Modifying a tools header without a corresponding kernel header update causes a synchronization…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Modifying a tools header without a corresponding kernel header update causes a synchronization divergence and triggers build warnings. --
commit f29e894bc895095793a45b66351922174d49d6a4
Author: Dapeng Mi <[email protected]>
tools headers: Sync x86 headers with kernel sources
This commit attempts to synchronize the x86 msr-index.h header in the tools directory with the kernel sources by adding ARCH_PEBS_VECR_xxx macros.
tools/arch/x86/include/asm/msr-index.h line 353
Quoted 9 lines
tools/arch/x86/include/asm/msr-index.h +1
-0@@ -350,6 +350,13 @@#define ARCH_PEBS_LBR_SHIFT 40#define ARCH_PEBS_LBR (0x3ull << ARCH_PEBS_LBR_SHIFT)#define ARCH_PEBS_VECR_XMM BIT_ULL(49) +#define ARCH_PEBS_VECR_YMMH BIT_ULL(50)
[Severity: Low]
Will this trigger a Kernel ABI header differences warning during the perf build?
If the corresponding kernel-side macros are not already present in the arch/x86/include/asm/msr-index.h header of the tree this patch is applied against, check-headers.sh will flag a synchronization divergence.
Are these macros being merged in a separate patch series that needs to be applied first, or did the kernel counterpart miss getting included in this series?
Quoted 2 lines
tools/arch/x86/include/asm/msr-index.h +2
-0+#define ARCH_PEBS_VECR_EGPRS BIT_ULL(51) +#define ARCH_PEBS_VECR_OPMASK BIT_ULL(53)
[ ... ]
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Re: [Patch v9 03/10] tools headers: Sync x86 headers with kernel sources
Quoted 25 lines · On 7/6/2026 10:54 AM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Low] Modifying a tools header without a corresponding kernel header update causes a synchronization divergence and triggers build warnings. --commit
f29e894bc895095793a45b66351922174d49d6a4
Author: Dapeng Mi <[email protected]>tools headers: Sync x86 headers with kernel sources
This commit attempts to synchronize the x86
msr-index.hheader in the tools directory with the kernel sources by addingARCH_PEBS_VECR_xxxmacros.tools/arch/x86/include/asm/msr-index.h line 353
Quoted 9 lines
tools/arch/x86/include/asm/msr-index.h +1
-0@@ -350,6 +350,13 @@#define ARCH_PEBS_LBR_SHIFT 40#define ARCH_PEBS_LBR (0x3ull << ARCH_PEBS_LBR_SHIFT)#define ARCH_PEBS_VECR_XMM BIT_ULL(49) +#define ARCH_PEBS_VECR_YMMH BIT_ULL(50)[Severity: Low]
Will this trigger a Kernel ABI header differences warning during the perf build?
Quoted 7 lines
If the corresponding kernel-side macros are not already present in the
arch/x86/include/asm/msr-index.hheader of the tree this patch is applied against,check-headers.shwill flag a synchronization divergence.Are these macros being merged in a separate patch series that needs to be applied first, or did the kernel counterpart miss getting included in this series?
The kernel header update is in a separate patchset which the cover letter has mentioned.
Quoted 5 lines
Quoted 3 lines
tools/arch/x86/include/asm/msr-index.h +2
-0+#define ARCH_PEBS_VECR_EGPRS BIT_ULL(51) +#define ARCH_PEBS_VECR_OPMASK BIT_ULL(53)[ ... ]
PATCH v9 4/10 perf headers: Sync perf_event.h/perf_regs.h with the kernel headers
In reply to Dapeng MiSync the UAPI header changes of supporting SIMD/eGPRs/SSP sampling into corresponding tools UAPI headers.
Additionally, support the new introduced perf_event_attr fields in the perf_event_attr__fprintf and perf_event__attr_swap() helpers, and add sanity check for the new introduced __reserved_4 field in perf_attr_check().
--- tools/arch/x86/include/uapi/asm/perf_regs.h | 53 +++++++++++++++++++++ tools/include/uapi/linux/perf_event.h | 49 +++++++++++++++++-- tools/perf/util/header.c | 3 +- tools/perf/util/perf_event_attr_fprintf.c | 11 ++++- tools/perf/util/session.c | 7 +++ 5 files changed, 117 insertions(+), 6 deletions(-)
tools/arch/x86/include/uapi/asm/perf_regs.h +53 -0
@@ -2,6 +2,8 @@#ifndef _ASM_X86_PERF_REGS_H#define _ASM_X86_PERF_REGS_H +#include <linux/bits.h> +enum perf_event_x86_regs {PERF_REG_X86_AX , PERF_REG_X86_BX,
@@ -27,9 +29,35 @@ enum perf_event_x86_regs {PERF_REG_X86_R13 ,PERF_REG_X86_R14 ,PERF_REG_X86_R15 , +/* +* The eGPRs/SSP and XMM have overlaps. Only one can be used +* at a time. The ABI PERF_SAMPLE_REGS_ABI_SIMD is used to +* distinguish which one is used. If PERF_SAMPLE_REGS_ABI_SIMD +* is set, then eGPRs/SSP is used, otherwise, XMM is used. +* +* Extended GPRs (eGPRs) +*/ +PERF_REG_X86_R16 , +PERF_REG_X86_R17 , +PERF_REG_X86_R18 , +PERF_REG_X86_R19 , +PERF_REG_X86_R20 , +PERF_REG_X86_R21 , +PERF_REG_X86_R22 , +PERF_REG_X86_R23 , +PERF_REG_X86_R24 , +PERF_REG_X86_R25 , +PERF_REG_X86_R26 , +PERF_REG_X86_R27 , +PERF_REG_X86_R28 , +PERF_REG_X86_R29 , +PERF_REG_X86_R30 , +PERF_REG_X86_R31 , +PERF_REG_X86_SSP ,/* These are the limits for the GPRs. */ PERF_REG_X86_32_MAX =PERF_REG_X86_GS +1 ,PERF_REG_X86_64_MAX =PERF_REG_X86_R15 +1 , +PERF_REG_MISC_MAX =PERF_REG_X86_SSP +1 ,/* These all need two bits set because they are 128bit */ PERF_REG_X86_XMM0 = 32,
@@ -54,5 +82,30 @@ enum perf_event_x86_regs { };#define PERF_REG_EXTENDED_MASK (~((1ULL << PERF_REG_X86_XMM0) - 1)) +#define PERF_X86_EGPRS_MASK __GENMASK_ULL(PERF_REG_X86_R31, PERF_REG_X86_R16) + +enum { +PERF_X86_SIMD_XMM_REGS =16 , +PERF_X86_SIMD_YMM_REGS =16 , +PERF_X86_SIMD_ZMM_REGS =32 , +PERF_X86_SIMD_VEC_REGS_MAX =PERF_X86_SIMD_ZMM_REGS , + +PERF_X86_SIMD_OPMASK_REGS =8 , +PERF_X86_SIMD_PRED_REGS_MAX =PERF_X86_SIMD_OPMASK_REGS , +}; + +#define PERF_X86_SIMD_PRED_MASK __GENMASK(PERF_X86_SIMD_PRED_REGS_MAX - 1, 0) +#define PERF_X86_SIMD_VEC_MASK __GENMASK_ULL(PERF_X86_SIMD_VEC_REGS_MAX - 1, 0) + +#define PERF_X86_H16ZMM_BASE 16 + +enum { +/* 1 qword = 8 bytes */ +PERF_X86_OPMASK_QWORDS =1 , +PERF_X86_XMM_QWORDS =2 , +PERF_X86_YMM_QWORDS =4 , +PERF_X86_ZMM_QWORDS =8 , +PERF_X86_SIMD_QWORDS_MAX =PERF_X86_ZMM_QWORDS , +};#endif /* _ASM_X86_PERF_REGS_H */
tools/include/uapi/linux/perf_event.h +45 -4
79 lines not on this page · raw message
tools/perf/util/header.c +2 -1
@@ -2162,7 +2162,8 @@ static void free_event_desc(struct evsel *events)static bool perf_attr_check (struct perf_event_attr *attr) { -if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3) { +if (attr->__reserved_1 || attr->__reserved_2 || + attr->__reserved_3 || attr->__reserved_4) {pr_warning ("Reserved bits are set unexpectedly. " "Please update perf tool.\n" );return false;
tools/perf/util/perf_event_attr_fprintf.c +10 -1
@@ -407,8 +407,17 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr, }if (attr_size >= offsetof(struct perf_event_attr , config4))PRINT_ATTRf (config3, p_hex); -if (attr_size > offsetof(struct perf_event_attr , config4)) +if (attr_size >= offsetof(struct perf_event_attr , sample_simd_regs_enabled))PRINT_ATTRf (config4, p_hex); +if (attr_size > offsetof(struct perf_event_attr , sample_simd_vec_reg_user)) { +PRINT_ATTRf (sample_simd_regs_enabled, p_unsigned); +PRINT_ATTRf (sample_simd_pred_reg_qwords, p_unsigned); +PRINT_ATTRf (sample_simd_pred_reg_intr, p_hex); +PRINT_ATTRf (sample_simd_pred_reg_user, p_hex); +PRINT_ATTRf (sample_simd_vec_reg_qwords, p_unsigned); +PRINT_ATTRf (sample_simd_vec_reg_intr, p_hex); +PRINT_ATTRf (sample_simd_vec_reg_user, p_hex); + }return ret; }
tools/perf/util/session.c +7 -0
@@ -639,6 +639,13 @@ do { \bswap_field_64 (sig_data);bswap_field_64 (config3);bswap_field_64 (config4); +bswap_field_16 (sample_simd_regs_enabled); +bswap_field_16 (sample_simd_pred_reg_qwords); +bswap_field_16 (sample_simd_vec_reg_qwords); +bswap_field_32 (sample_simd_pred_reg_intr); +bswap_field_32 (sample_simd_pred_reg_user); +bswap_field_64 (sample_simd_vec_reg_intr); +bswap_field_64 (sample_simd_vec_reg_user);/* * After read_format are bitfields. Check read_format because
Signature · 1 line
2.34.1
PATCH v9 5/10 perf regs: Support x86 eGPRs/SSP sampling
In reply to Dapeng MiAdd support for sampling x86 extended GP registers (R16-R31) and the shadow stack pointer (SSP) register.
The original XMM registers space in sample_regs_user/sample_regs_intr is reclaimed to represent the eGPRs and SSP when SIMD registers sampling is supported with the new SIMD sampling fields in the perf_event_attr structure. This necessitates a way to distinguish which register layout is used for the sample_regs_user/sample_regs_intr bitmap.
To address this, a new "abi" argument is added to the helpers perf_intr_reg_mask(), perf_user_reg_mask(), and perf_reg_name(). When "abi & PERF_SAMPLE_REGS_ABI_SIMD" is true, it indicates the eGPRs and SSP layout is represented; otherwise, the legacy XMM registers are represented.
Please note that PERF_SAMPLE_REGS_ABI_SIMD is set by default on platforms that support SIMD register sampling, even when no eGPR or SSP register is requested (for example, -Iax). As a result, sample_regs_intr and sample_regs_usr always use the new GPR layout on platforms with SIMD register sampling support.
The patch only supports eGPRs and SSP sampling, the complete SIMD registers sampling would be supported in the next patch.
--- tools/perf/builtin-script.c | 2 +- tools/perf/util/evsel.c | 23 +++- tools/perf/util/parse-regs-options.c | 35 +++-- .../perf/util/perf-regs-arch/perf_regs_x86.c | 124 +++++++++++++++--- tools/perf/util/perf_regs.c | 12 +- tools/perf/util/perf_regs.h | 10 +- tools/perf/util/record.h | 7 + .../scripting-engines/trace-event-python.c | 2 +- tools/perf/util/session.c | 13 +- tools/perf/util/synthetic-events.c | 4 + 10 files changed, 187 insertions(+), 45 deletions(-)
tools/perf/builtin-script.c +1 -1
@@ -734,7 +734,7 @@ static int perf_sample__fprintf_regs(struct regs_dump *regs, uint64_t mask,for_each_set_bit (r, (unsigned long *) &mask,sizeof (mask) *8 ) {u64 val = regs->regs[i++]; printed +=fprintf (fp,"%5s:0x%" PRIx64" " , -perf_reg_name (r, e_machine, e_flags), +perf_reg_name (r, e_machine, e_flags, regs->abi), val); }
tools/perf/util/evsel.c +21 -2
@@ -1119,19 +1119,22 @@ static void __evsel__config_callchain(struct evsel *evsel, const struct record_o }if (param->record_mode ==CALLCHAIN_DWARF ) { +int abi =-1 ;/* -1 indicates only basic GPRs are needed. */ +if (!function) {uint16_t e_machine =evsel__e_machine (evsel,/*e_flags=*/ NULL );evsel__set_sample_bit (evsel,REGS_USER );evsel__set_sample_bit (evsel,STACK_USER );if (opts->sample_user_regs && -DWARF_MINIMAL_REGS (e_machine) !=perf_user_reg_mask (EM_HOST )) { +DWARF_MINIMAL_REGS (e_machine) !=perf_user_reg_mask (EM_HOST , &abi)) { attr->sample_regs_user |=DWARF_MINIMAL_REGS (e_machine);pr_warning ("WARNING: The use of --call-graph=dwarf may require all the user registers, " "specifying a subset with --user-regs may render DWARF unwinding unreliable, " "so the minimal registers set (IP, SP) is explicitly forced.\n" ); }else { - attr->sample_regs_user |=perf_user_reg_mask (EM_HOST ); + abi =-1 ; + attr->sample_regs_user |=perf_user_reg_mask (EM_HOST , &abi); } attr->sample_stack_user = param->dump_size; attr->exclude_callchain_user =1 ;
@@ -1657,12 +1660,14 @@ void evsel__config(struct evsel *evsel, const struct record_opts *opts,if (opts->sample_intr_regs && !evsel->no_aux_samples && !evsel__is_dummy_event (evsel)) { attr->sample_regs_intr = opts->sample_intr_regs; + attr->sample_simd_regs_enabled = !!opts->sample_simd_regs_enabled;evsel__set_sample_bit (evsel,REGS_INTR ); }if (opts->sample_user_regs && !evsel->no_aux_samples && !evsel__is_dummy_event (evsel)) { attr->sample_regs_user |= opts->sample_user_regs; + attr->sample_simd_regs_enabled = !!opts->sample_simd_regs_enabled;evsel__set_sample_bit (evsel,REGS_USER ); }
@@ -3690,6 +3695,13 @@ int __evsel__parse_sample(struct evsel *evsel, union perf_event *event, regs->mask = mask; regs->regs = (u64 *)array; array = (void *)array + sz; + +if (regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { +/* Skip SIMD-regs header. */ + sz =4 *sizeof (u64); +OVERFLOW_CHECK (array, sz, max_size); + array = (void *)array + sz; + } } }
@@ -3747,6 +3759,13 @@ int __evsel__parse_sample(struct evsel *evsel, union perf_event *event, regs->mask = mask; regs->regs = (u64 *)array; array = (void *)array + sz; + +if (regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { +/* Skip SIMD-regs header. */ + sz =4 *sizeof (u64); +OVERFLOW_CHECK (array, sz, max_size); + array = (void *)array + sz; + } } }
tools/perf/util/parse-regs-options.c +25 -10
@@ -6,11 +6,14 @@#include <stdio.h> #include "util/debug.h" #include <dwarf-regs.h> +#include <sys/param.h> #include <subcmd/parse-options.h> #include "util/perf_regs.h" #include "util/parse-regs-options.h" +#include "record.h" -static void list_perf_regs (FILE *fp,uint64_t mask) +static void +list_perf_regs (FILE *fp,uint64_t mask,int abi) {const char *last_name =NULL ;
@@ -21,7 +24,7 @@ static void list_perf_regs(FILE *fp, uint64_t mask)if (((1ULL << reg) & mask) ==0 )continue ; - name =perf_reg_name (reg,EM_HOST ,EF_HOST ); + name =perf_reg_name (reg,EM_HOST ,EF_HOST , abi);if (name && (!last_name ||strcmp (last_name, name)))fprintf (fp,"%s%s" , reg >0 ?" " :"" , name); last_name = name;
@@ -29,7 +32,8 @@ static void list_perf_regs(FILE *fp, uint64_t mask)fputc ('\n' , fp); } -static uint64_t name_to_perf_reg_mask (const char *to_match,uint64_t mask) +static uint64_t +name_to_perf_reg_mask (const char *to_match,uint64_t mask,int abi) {uint64_t reg_mask =0 ;
@@ -39,7 +43,7 @@ static uint64_t name_to_perf_reg_mask(const char *to_match, uint64_t mask)if (((1ULL << reg) & mask) ==0 )continue ; - name =perf_reg_name (reg,EM_HOST ,EF_HOST ); + name =perf_reg_name (reg,EM_HOST ,EF_HOST , abi);if (!name)continue ;
@@ -53,9 +57,12 @@ static int __parse_regs(const struct option *opt, const char *str, int unset, bool intr) { uint64_t *mode = (uint64_t *)opt->value; +struct record_opts *opts;char *s, *os =NULL , *p; +const char *warn;int ret =-1 ;uint64_t mask; +int abi =0 ;if (unset)return 0 ;
@@ -66,11 +73,16 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr)if (*mode)return -1 ; - mask = intr ?perf_intr_reg_mask (EM_HOST ) :perf_user_reg_mask (EM_HOST ); + mask = intr ?perf_intr_reg_mask (EM_HOST , &abi) : +perf_user_reg_mask (EM_HOST , &abi); + opts = intr ? container_of(opt->value, struct record_opts, sample_intr_regs) : + container_of(opt->value, struct record_opts, sample_user_regs);/* str may be NULL in case no arg is passed to -I */ if (!str) { *mode = mask; +if (abi &PERF_SAMPLE_REGS_ABI_SIMD ) + opts->sample_simd_regs_enabled =1 ;return 0 ; }
@@ -79,6 +91,7 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr)if (!s)return -1 ; + warn ="Unknown register \"%s\", check man page or run \"perf record %s?\"\n" ;for (;;) {uint64_t reg_mask;
@@ -87,14 +100,16 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr) *p ='\0' ;if (!strcmp (s,"?" )) { -list_perf_regs (stderr, mask); +list_perf_regs (stderr, mask, abi); goto error; } - reg_mask =name_to_perf_reg_mask (s, mask); -if (reg_mask ==0 ) { -ui__warning ("Unknown register \"%s\", check man page or run \"perf record %s?\"\n" , - s, intr ?"-I" :"--user-regs=" ); + reg_mask =name_to_perf_reg_mask (s, mask, abi); +if (reg_mask) { +if (abi &PERF_SAMPLE_REGS_ABI_SIMD ) + opts->sample_simd_regs_enabled =1 ; + }else { +ui__warning (warn, s, intr ?"-I" :"--user-regs=" ); goto error; } *mode |= reg_mask;
tools/perf/util/perf-regs-arch/perf_regs_x86.c +109 -15
161 lines not on this page · raw message
tools/perf/util/perf_regs.c +6 -6
@@ -38,7 +38,7 @@ int perf_sdt_arg_parse_op(uint16_t e_machine, char *old_op, char **new_op)return ret; } -uint64_t perf_intr_reg_mask (uint16_t e_machine) +uint64_t perf_intr_reg_mask (uint16_t e_machine,int *abi/*inout*/ ) {uint64_t mask =0 ;
@@ -70,7 +70,7 @@ uint64_t perf_intr_reg_mask(uint16_t e_machine)break ;case EM_386 :case EM_X86_64 : - mask =__perf_reg_mask_x86 (/*intr=*/ true); + mask =__perf_reg_mask_x86 (/*intr=*/ true, abi);break ;default : pr_debug("Unknown ELF machine %d, interrupt sampling register mask will be empty.\n",
@@ -81,7 +81,7 @@ uint64_t perf_intr_reg_mask(uint16_t e_machine)return mask; } -uint64_t perf_user_reg_mask (uint16_t e_machine) +uint64_t perf_user_reg_mask (uint16_t e_machine,int *abi/*inout*/ ) {uint64_t mask =0 ;
@@ -113,7 +113,7 @@ uint64_t perf_user_reg_mask(uint16_t e_machine)break ;case EM_386 :case EM_X86_64 : - mask =__perf_reg_mask_x86 (/*intr=*/ false); + mask =__perf_reg_mask_x86 (/*intr=*/ false, abi);break ;default : pr_debug("Unknown ELF machine %d, user sampling register mask will be empty.\n",
@@ -124,7 +124,7 @@ uint64_t perf_user_reg_mask(uint16_t e_machine)return mask; } -const char *perf_reg_name (int id,uint16_t e_machine,uint32_t e_flags) +const char *perf_reg_name (int id,uint16_t e_machine,uint32_t e_flags,int abi) {const char *reg_name =NULL ;
@@ -156,7 +156,7 @@ const char *perf_reg_name(int id, uint16_t e_machine, uint32_t e_flags)break ;case EM_386 :case EM_X86_64 : - reg_name =__perf_reg_name_x86 (id); + reg_name =__perf_reg_name_x86 (id, abi);break ;default :break ;
tools/perf/util/perf_regs.h +5 -5
@@ -13,10 +13,10 @@ enum { };int perf_sdt_arg_parse_op (uint16_t e_machine,char *old_op,char **new_op); -uint64_t perf_intr_reg_mask (uint16_t e_machine); -uint64_t perf_user_reg_mask (uint16_t e_machine); +uint64_t perf_intr_reg_mask (uint16_t e_machine,int *abi/*inout*/ ); +uint64_t perf_user_reg_mask (uint16_t e_machine,int *abi/*inout*/ ); -const char *perf_reg_name (int id,uint16_t e_machine,uint32_t e_flags); +const char *perf_reg_name (int id,uint16_t e_machine,uint32_t e_flags,int abi);int perf_reg_value (u64 *valp,struct regs_dump *regs,int id);uint64_t perf_arch_reg_ip (uint16_t e_machine);uint64_t perf_arch_reg_sp (uint16_t e_machine);
@@ -66,8 +66,8 @@ uint64_t __perf_reg_sp_s390(void);int __perf_sdt_arg_parse_op_s390 (char *old_op,char **new_op);int __perf_sdt_arg_parse_op_x86 (char *old_op,char **new_op); -uint64_t __perf_reg_mask_x86 (bool intr); -const char *__perf_reg_name_x86 (int id); +uint64_t __perf_reg_mask_x86 (bool intr,int *abi); +const char *__perf_reg_name_x86 (int id,int abi);uint64_t __perf_reg_ip_x86 (void );uint64_t __perf_reg_sp_x86 (void );
tools/perf/util/record.h +7 -0
@@ -62,6 +62,13 @@ struct record_opts {u64 branch_stack;u64 sample_intr_regs;u64 sample_user_regs; +u16 sample_simd_regs_enabled; +u16 sample_vec_reg_qwords; +u16 sample_pred_reg_qwords; +u32 sample_intr_pred_regs; +u32 sample_user_pred_regs; +u64 sample_intr_vec_regs; +u64 sample_user_vec_regs;u64 default_interval;u64 user_interval;size_t auxtrace_snapshot_size;
tools/perf/util/scripting-engines/trace-event-python.c +1 -1
@@ -730,7 +730,7 @@ static void regs_map(struct regs_dump *regs, uint64_t mask, uint16_t e_machine, printed +=scnprintf (bf + printed, size - printed,"%5s:0x%" PRIx64" " , -perf_reg_name (r, e_machine, e_flags), val); +perf_reg_name (r, e_machine, e_flags, regs->abi), val); } }
tools/perf/util/session.c +8 -5
@@ -1433,15 +1433,16 @@ static void branch_stack__printf(struct perf_sample *sample, } } -static void regs_dump__printf (u64 mask,u64 *regs,uint16_t e_machine,uint32_t e_flags) +static void regs_dump__printf (u64 mask,struct regs_dump *regs, +uint16_t e_machine,uint32_t e_flags) {unsigned rid, i =0 ;for_each_set_bit (rid, (unsigned long *) &mask,sizeof (mask) *8 ) { -u64 val = regs[i++]; +u64 val = regs->regs[i++];printf (".... %-5s 0x%016" PRIx64"\n" , -perf_reg_name (rid, e_machine, e_flags), val); +perf_reg_name (rid, e_machine, e_flags, regs->abi), val); } }
@@ -1449,11 +1450,13 @@ static const char *regs_abi[] = { [PERF_SAMPLE_REGS_ABI_NONE] = "none", [PERF_SAMPLE_REGS_ABI_32] = "32-bit", [PERF_SAMPLE_REGS_ABI_64] = "64-bit", + [PERF_SAMPLE_REGS_ABI_SIMD | PERF_SAMPLE_REGS_ABI_32] = "32-bit SIMD", + [PERF_SAMPLE_REGS_ABI_SIMD | PERF_SAMPLE_REGS_ABI_64] = "64-bit SIMD", };static inline const char *regs_dump_abi (struct regs_dump *d) { -if (d->abi >PERF_SAMPLE_REGS_ABI_64 ) +if (d->abi >=ARRAY_SIZE (regs_abi) || !regs_abi[d->abi])return "unknown" ;return regs_abi[d->abi];
@@ -1469,7 +1472,7 @@ static void regs__printf(const char *type, struct regs_dump *regs, mask, regs_dump_abi(regs)); -regs_dump__printf (mask, regs->regs, e_machine, e_flags); +regs_dump__printf (mask, regs, e_machine, e_flags); }static void regs_user__printf (struct perf_sample *sample,uint16_t e_machine,uint32_t e_flags)
tools/perf/util/synthetic-events.c +4 -0
@@ -1527,6 +1527,8 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,if (sample->user_regs && sample->user_regs->abi) { result +=sizeof (u64); sz =hweight64 (sample->user_regs->mask) *sizeof (u64); +if (sample->user_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) + sz +=4 *sizeof (u64); result += sz; }else { result +=sizeof (u64);
@@ -1555,6 +1557,8 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,if (sample->intr_regs && sample->intr_regs->abi) { result +=sizeof (u64); sz =hweight64 (sample->intr_regs->mask) *sizeof (u64); +if (sample->intr_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) + sz +=4 *sizeof (u64); result += sz; }else { result +=sizeof (u64);
Signature · 1 line
2.34.1
[email protected]
AI reviewRe: [Patch v9 05/10] perf regs: Support x86 eGPRs/SSP sampling
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Reclaiming XMM register space breaks explicit XMM register selection on SIMD-capable hosts. --
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Reclaiming XMM register space breaks explicit XMM register selection on SIMD-capable hosts. --
commit 4a688e42468a5e89b85174c21cc87866b350369c
Author: Dapeng Mi <[email protected]>
perf regs: Support x86 eGPRs/SSP sampling
This commit adds support for sampling x86 extended GP registers (R16-R31) and the shadow stack pointer (SSP) by reclaiming the original XMM register space. A new abi argument is introduced to distinguish the register layout, defaulting to the new SIMD layout on supported platforms.
Quoted 3 lines
tools/perf/util/parse-regs-options.c +0
-0
[ ... ]
Quoted 9 lines
tools/perf/util/parse-regs-options.c +1
-1@@ -87,14 +100,16 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr) *p ='\0' ;if (!strcmp (s,"?" )) { -list_perf_regs (stderr, mask); +list_perf_regs (stderr, mask, abi); goto error; }
tools/perf/util/parse-regs-options.c __parse_regs(const struct option *opt, const char *str, int unset, bool intr) · line 112
Quoted 10 lines
tools/perf/util/parse-regs-options.c +6
-4- reg_mask =name_to_perf_reg_mask (s, mask); -if (reg_mask ==0 ) { -ui__warning ("Unknown register \"%s\", check man page or run \"perf record %s?\"\n" , - s, intr ?"-I" :"--user-regs=" ); + reg_mask =name_to_perf_reg_mask (s, mask, abi); +if (reg_mask) { +if (abi &PERF_SAMPLE_REGS_ABI_SIMD ) + opts->sample_simd_regs_enabled =1 ; + }else { +ui__warning (warn, s, intr ?"-I" :"--user-regs=" );
[Severity: Medium]
Will this change break explicit XMM register selection on SIMD-capable hosts?
Because PERF_SAMPLE_REGS_ABI_SIMD is set by default on platforms with SIMD support, the reclaimed register space means name_to_perf_reg_mask will now map to eGPRs instead of XMM registers.
If a user runs an existing script that explicitly requests individual XMM registers, such as perf record -I xmm0, won't this branch fail to match the string, return an Unknown register warning, and break backward compatibility for those CLI options?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=5
Re: [Patch v9 05/10] perf regs: Support x86 eGPRs/SSP sampling
Quoted 40 lines · On 7/6/2026 10:59 AM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Reclaiming XMM register space breaks explicit XMM register selection on SIMD-capable hosts. --commit
4a688e42468a5e89b85174c21cc87866b350369c
Author: Dapeng Mi <[email protected]>perf regs: Support x86 eGPRs/SSP sampling
This commit adds support for sampling x86 extended GP registers (R16-R31) and the shadow stack pointer (SSP) by reclaiming the original XMM register space. A new abi argument is introduced to distinguish the register layout, defaulting to the new SIMD layout on supported platforms.
Quoted 3 lines
tools/perf/util/parse-regs-options.c +0
-0[ ... ]
Quoted 9 lines
tools/perf/util/parse-regs-options.c +1
-1@@ -87,14 +100,16 @@ __parse_regs(const struct option *opt, const char *str, int unset, bool intr) *p ='\0' ;if (!strcmp (s,"?" )) { -list_perf_regs (stderr, mask); +list_perf_regs (stderr, mask, abi); goto error; }tools/perf/util/parse-regs-options.c __parse_regs(const struct option *opt, const char *str, int unset, bool intr) · line 112
Quoted 10 lines
tools/perf/util/parse-regs-options.c +6
-4- reg_mask =name_to_perf_reg_mask (s, mask); -if (reg_mask ==0 ) { -ui__warning ("Unknown register \"%s\", check man page or run \"perf record %s?\"\n" , - s, intr ?"-I" :"--user-regs=" ); + reg_mask =name_to_perf_reg_mask (s, mask, abi); +if (reg_mask) { +if (abi &PERF_SAMPLE_REGS_ABI_SIMD ) + opts->sample_simd_regs_enabled =1 ; + }else { +ui__warning (warn, s, intr ?"-I" :"--user-regs=" );[Severity: Medium]
Will this change break explicit XMM register selection on SIMD-capable hosts?
Quoted 8 lines
Because
PERF_SAMPLE_REGS_ABI_SIMDis set by default on platforms with SIMD support, the reclaimed register space meansname_to_perf_reg_maskwill now map to eGPRs instead of XMM registers.If a user runs an existing script that explicitly requests individual XMM registers, such as perf record -I xmm0, won't this branch fail to match the string, return an Unknown register warning, and break backward compatibility for those CLI options?
The User should run "perf record -I?" or "perf record --user-regs=?" to get the supported registers before running "perf record -I xmm0".
PATCH v9 6/10 perf regs: Support x86 SIMD registers sampling
In reply to Dapeng MiAdd support for the newly introduced SIMD register sampling format by adding the following 5 functions:
uint64_t perf_intr_simd_reg_class_mask(uint16_t e_machine, bool pred); uint64_t perf_user_simd_reg_class_mask(uint16_t e_machine, bool pred); uint64_t perf_intr_simd_reg_class_bitmap_qwords(uint16_t e_machine, int reg_c,
uint16_t *qwords, bool pred); uint64_t perf_user_simd_reg_class_bitmap_qwords(uint16_t e_machine, int reg_c, uint16_t *qwords, bool pred);
const char *perf_simd_reg_class_name(uint16_t e_machine, int id, bool pred);
The perf_{intr|user}_simd_reg_class_mask() functions retrieve the bitmap of kernel supported SIMD/PRED register classes on current platform for intr-regs and user-regs sampling, such as OPMASK/XMM/YMM/ZMM on x86 platforms.
The perf_{intr|user}_simd_reg_class_bitmap_qwords() functions retrieve the bitmap and qwords length of a certain class of SIMD/PRED register on current platform for intr-regs and user-regs sampling. For example, for the XMM registers on x86 platforms, the returned bitmap is 0xffff (XMM0 ~ XMM15) and the qwords length is 2 (128 bits for each XMM register).
The perf_simd_reg_class_name() function gets the register class name for a certain register class index.
Additionally, the function __parse_regs() is enhanced to support parsing these newly introduced SIMD/PRED registers. Currently, each class of register can only be sampled collectively; sampling a specific SIMD register is not supported. For example, all XMM registers are sampled together rather than sampling only XMM0.
When multiple overlapping register types, such as XMM and YMM, are sampled simultaneously, only the superset (YMM registers) is sampled.
With this patch, all supported sampling registers on x86 platforms are displayed as follows.
$perf record --intr-regs=?
available registers: AX BX CX DX SI DI BP SP IP FLAGS CS SS R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R30 R31 SSP XMM0-15 YMM0-15 ZMM0-31 OPMASK0-7
$perf record --user-regs=?
available registers: AX BX CX DX SI DI BP SP IP FLAGS CS SS R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29 R30 R31 SSP XMM0-15 YMM0-15 ZMM0-31 OPMASK0-7
--- tools/perf/Documentation/perf-record.txt | 10 +- tools/perf/util/evsel.c | 21 ++ tools/perf/util/parse-regs-options.c | 161 +++++++++- .../perf/util/perf-regs-arch/perf_regs_x86.c | 292 ++++++++++++++++++ tools/perf/util/perf_regs.c | 72 +++++ tools/perf/util/perf_regs.h | 11 + 6 files changed, 550 insertions(+), 17 deletions(-)
tools/perf/Documentation/perf-record.txt +7 -3
@@ -513,12 +513,16 @@ Capture machine state (registers) at interrupt, i.e., on counter overflows for each sample. List of captured registers depends on the architecture. This option is off by default. It is possible to select the registers to sample using their symbolic names, e.g. on x86, ax, si. To list the available registers use ---intr-regs=\?. To name registers, pass a comma separated list such as ---intr-regs=ax,bx. The list of register is architecture dependent. +--intr-regs=\?. On supported architectures, SIMD registers are displayed as +groups (e.g., on x86: XMM0-15,YMM0-15,ZMM0-31). To name registers, pass a comma +separated list such as --intr-regs=ax,bx,zmm. Please notice SIMD registers must +be assigned as a complete set, sampling individual SIMD registers (e.g., zmm0) +is not supported. The list of register is architecture dependent. --user-regs:: Similar to -I, but capture user registers at sample time. To list the available -user registers use --user-regs=\?. +user registers use --user-regs=\?. For SIMD registers, only complete register +sets are allowed like -I. --running-time:: Record running and enabled time for read events (:S)
tools/perf/util/evsel.c +21 -0
@@ -29,6 +29,7 @@#include <sys/resource.h> #include <sys/syscall.h> #include <sys/types.h> +#include <sys/param.h> #include <api/fs/fs.h> #include <api/fs/tracing_path.h>
@@ -1664,6 +1665,16 @@ void evsel__config(struct evsel *evsel, const struct record_opts *opts,evsel__set_sample_bit (evsel,REGS_INTR ); } +if ((opts->sample_intr_vec_regs || opts->sample_intr_pred_regs) && + !evsel->no_aux_samples && !evsel__is_dummy_event (evsel)) { + attr->sample_simd_regs_enabled = !!opts->sample_simd_regs_enabled; + attr->sample_simd_vec_reg_intr = opts->sample_intr_vec_regs; + attr->sample_simd_vec_reg_qwords = opts->sample_vec_reg_qwords; + attr->sample_simd_pred_reg_intr = opts->sample_intr_pred_regs; + attr->sample_simd_pred_reg_qwords = opts->sample_pred_reg_qwords; +evsel__set_sample_bit (evsel,REGS_INTR ); + } +if (opts->sample_user_regs && !evsel->no_aux_samples && !evsel__is_dummy_event (evsel)) { attr->sample_regs_user |= opts->sample_user_regs;
@@ -1671,6 +1682,16 @@ void evsel__config(struct evsel *evsel, const struct record_opts *opts,evsel__set_sample_bit (evsel,REGS_USER ); } +if ((opts->sample_user_vec_regs || opts->sample_user_pred_regs) && + !evsel->no_aux_samples && !evsel__is_dummy_event (evsel)) { + attr->sample_simd_regs_enabled = !!opts->sample_simd_regs_enabled; + attr->sample_simd_vec_reg_user = opts->sample_user_vec_regs; + attr->sample_simd_vec_reg_qwords = opts->sample_vec_reg_qwords; + attr->sample_simd_pred_reg_user = opts->sample_user_pred_regs; + attr->sample_simd_pred_reg_qwords = opts->sample_pred_reg_qwords; +evsel__set_sample_bit (evsel,REGS_USER ); + } +if (target__has_cpu (&opts->target) || opts->sample_cpu)evsel__set_sample_bit (evsel,CPU );
tools/perf/util/parse-regs-options.c +147 -14
221 lines not on this page · raw message
tools/perf/util/perf-regs-arch/perf_regs_x86.c +292 -0
295 lines not on this page · raw message
tools/perf/util/perf_regs.c +72 -0
75 lines not on this page · raw message
tools/perf/util/perf_regs.h +11 -0
@@ -20,6 +20,13 @@ const char *perf_reg_name(int id, uint16_t e_machine, uint32_t e_flags, int abi)int perf_reg_value (u64 *valp,struct regs_dump *regs,int id);uint64_t perf_arch_reg_ip (uint16_t e_machine);uint64_t perf_arch_reg_sp (uint16_t e_machine); +uint64_t perf_intr_simd_reg_class_mask (uint16_t e_machine,bool pred); +uint64_t perf_user_simd_reg_class_mask (uint16_t e_machine,bool pred); +uint64_t perf_intr_simd_reg_class_bitmap_qwords (uint16_t e_machine,int reg_c, +uint16_t *qwords,bool pred); +uint64_t perf_user_simd_reg_class_bitmap_qwords (uint16_t e_machine,int reg_c, +uint16_t *qwords,bool pred); +const char *perf_simd_reg_class_name (uint16_t e_machine,int id,bool pred);int __perf_sdt_arg_parse_op_arm64 (char *old_op,char **new_op);uint64_t __perf_reg_mask_arm64 (bool intr);
@@ -70,6 +77,10 @@ uint64_t __perf_reg_mask_x86(bool intr, int *abi);const char *__perf_reg_name_x86 (int id,int abi);uint64_t __perf_reg_ip_x86 (void );uint64_t __perf_reg_sp_x86 (void ); +uint64_t __perf_simd_reg_class_mask_x86 (bool intr,bool pred); +uint64_t __perf_simd_reg_class_bitmap_qwords_x86 (int reg_c,uint16_t *qwords, +bool intr,bool pred); +const char *__perf_simd_reg_class_name_x86 (int id,bool pred);static inline uint64_t DWARF_MINIMAL_REGS (uint16_t e_machine) {
Signature · 1 line
2.34.1
PATCH v9 7/10 perf regs: Enable dumping of SIMD registers
In reply to Dapeng MiSupport dumping of SIMD registers with the new PERF_SAMPLE_REGS_ABI_SIMD ABI.
Currently, the XMM, YMM, ZMM, OPMASK, eGPRs, and SSP registers on x86 platforms are supported with the PERF_SAMPLE_REGS_ABI_SIMD ABI.
An example of the raw format output is displayed below.
Example:
$perf record -e cycles:p -Iax,bx,r8,r16,r31,ssp,xmm,ymm,zmm,opmask ./test $perf report -D
... ...
3342715685845 0x3afe8 [0xbc8]: PERF_RECORD_SAMPLE(IP, 0x1):
27776/27776: 0xffffffff91d7c18f period: 10000 addr: 0
... intr regs: mask 0x18001010003 ABI 64-bit SIMD
.... AX 0xffffed102de1a606 .... BX 0xffffed102de1a606 .... R8 0x0000000000000001 .... R16 0x0000000000000000 .... R31 0x0000000000000000 .... SSP 0x0000000000000000
... SIMD ABI nr_vectors 32 vector_qwords 8 nr_pred 8 pred_qwords 1 .... ZMM[0][0] 0x616c2f656d6f682f
.... ZMM[0][1] 0x696c2f7265737562
.... ZMM[0][2] 0x0000000000000000
.... ZMM[0][3] 0x0000000000000000
.... ZMM[0][4] 0x0000000000000000
.... ZMM[0][5] 0x0000000000000000
.... ZMM[0][6] 0x0000000000000000
.... ZMM[0][7] 0x0000000000000000
.... ZMM[1][0] 0x702f636578656269
.... ZMM[1][1] 0x65726f632d667265
.... ZMM[1][2] 0x0000000000000000
.... ZMM[1][3] 0x0000000000000000
.... ZMM[1][4] 0x0000000000000000
.... ZMM[1][5] 0x0000000000000000
.... ZMM[1][6] 0x0000000000000000
.... ZMM[1][7] 0x0000000000000000
... ...
.... ZMM[31][0] 0x0000000000000000
.... ZMM[31][1] 0x0000000000000000
.... ZMM[31][2] 0x0000000000000000
.... ZMM[31][3] 0x0000000000000000
.... ZMM[31][4] 0x0000000000000000
.... ZMM[31][5] 0x0000000000000000
.... ZMM[31][6] 0x0000000000000000
.... ZMM[31][7] 0x0000000000000000
.... OPMASK[0] 0x0000000000100221
.... OPMASK[1] 0x0000000000000020
.... OPMASK[2] 0x000000007fffffff
.... OPMASK[3] 0x0000000000000000
.... OPMASK[4] 0x0000000000000000
.... OPMASK[5] 0x0000000000000000
.... OPMASK[6] 0x0000000000000000
.... OPMASK[7] 0x0000000000000000
... ...
--- tools/perf/builtin-script.c | 91 +++++++++++-- tools/perf/util/evsel.c | 68 +++++++++- tools/perf/util/sample.h | 5 + .../scripting-engines/trace-event-python.c | 125 ++++++++++++++++-- tools/perf/util/session.c | 82 ++++++++++++ tools/perf/util/synthetic-events.c | 38 +++++- 6 files changed, 387 insertions(+), 22 deletions(-)
tools/perf/builtin-script.c +83 -8
@@ -719,23 +719,96 @@ static int perf_session__check_output_opt(struct perf_session *session)return 0 ; } -static int perf_sample__fprintf_regs (struct regs_dump *regs,uint64_t mask, +static int perf_sample__fprintf_regs (struct regs_dump *regs, +struct perf_event_attr *attr,uint16_t e_machine,uint32_t e_flags, -FILE *fp) +FILE *fp,bool intr) { -unsigned i =0 , r; +const char *name ="unknown" ; +int reg_c, idx, pred_base; +unsigned int i =0 , j, r; +uint16_t qwords;int printed =0 ; +uint64_t mask; -if (!regs || !regs->regs) +if (!regs || (!regs->regs && !regs->simd_data))return 0 ; printed +=fprintf (fp," ABI:%" PRIu64" " , regs->abi); + mask = intr ? attr->sample_regs_intr : attr->sample_regs_user;for_each_set_bit (r, (unsigned long *) &mask,sizeof (mask) *8 ) { -u64 val = regs->regs[i++]; +if (!regs->regs) +break ; printed +=fprintf (fp,"%5s:0x%" PRIx64" " ,perf_reg_name (r, e_machine, e_flags, regs->abi), - val); + regs->regs[i++]); + } + +if (!regs->simd_data) +return printed; + +if (!regs->nr_vectors && !regs->nr_pred) +return printed; + +for (reg_c =0 ; reg_c <64 ; reg_c++) { +if (!regs->nr_vectors) +break ; +if (intr) { +perf_intr_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + }else { +perf_user_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + } +if (regs->vector_qwords == qwords) { + name =perf_simd_reg_class_name (e_machine, reg_c,/*pred=*/ false); +break ; + } + } + +for (i =0 ; i < regs->nr_vectors; i++) { +for (j =0 ; j < regs->vector_qwords; j++) { + idx = i * regs->vector_qwords + j; +if (regs->vector_qwords >1 ) { + printed +=fprintf (fp,"%5s[%d][%d]:0x%" PRIx64" " , + name, i, j, regs->simd_data[idx]); + }else { + printed +=fprintf (fp,"%5s[%d]:0x%" PRIx64" " , + name, i, regs->simd_data[idx]); + } + } + } + + name ="unknown" ; +for (reg_c =0 ; reg_c <64 ; reg_c++) { +if (!regs->nr_pred) +break ; +if (intr) { +perf_intr_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ true); + }else { +perf_user_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ true); + } +if (regs->pred_qwords == qwords) { + name =perf_simd_reg_class_name (e_machine, reg_c,/*pred=*/ true); +break ; + } + } + + pred_base = regs->nr_vectors * regs->vector_qwords; +for (i =0 ; i < regs->nr_pred; i++) { +for (j =0 ; j < regs->pred_qwords; j++) { + idx = pred_base + i * regs->pred_qwords + j; +if (regs->pred_qwords >1 ) { + printed +=fprintf (fp,"%5s[%d][%d]:0x%" PRIx64" " , + name, i, j, regs->simd_data[idx]); + }else { + printed +=fprintf (fp,"%5s[%d]:0x%" PRIx64" " , + name, i, regs->simd_data[idx]); + } + } }return printed;
@@ -801,7 +874,8 @@ static int perf_sample__fprintf_iregs(struct perf_sample *sample,return 0 ;return perf_sample__fprintf_regs (perf_sample__intr_regs (sample), - attr->sample_regs_intr, e_machine, e_flags, fp); + attr, e_machine, e_flags, fp, +/*intr=*/ true); } static int perf_sample__fprintf_uregs(struct perf_sample *sample,
@@ -814,7 +888,8 @@ static int perf_sample__fprintf_uregs(struct perf_sample *sample,return 0 ;return perf_sample__fprintf_regs (perf_sample__user_regs (sample), - attr->sample_regs_user, e_machine, e_flags, fp); + attr, e_machine, e_flags, fp, +/*intr=*/ false); } static int perf_sample__fprintf_start(struct perf_script *script,
tools/perf/util/evsel.c +64 -4
82 lines not on this page · raw message
tools/perf/util/sample.h +5 -0
@@ -16,6 +16,11 @@ struct regs_dump {u64 abi;u64 mask;u64 *regs; +u64 nr_vectors; +u64 vector_qwords; +u64 nr_pred; +u64 pred_qwords; +u64 *simd_data;/* Cached values/mask filled by first register access. */ u64 cache_regs[PERF_SAMPLE_REGS_CACHE_SIZE ];
tools/perf/util/scripting-engines/trace-event-python.c +117 -8
164 lines not on this page · raw message
tools/perf/util/session.c +82 -0
100 lines not on this page · raw message
tools/perf/util/synthetic-events.c +36 -2
@@ -1527,8 +1527,13 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,if (sample->user_regs && sample->user_regs->abi) { result +=sizeof (u64); sz =hweight64 (sample->user_regs->mask) *sizeof (u64); -if (sample->user_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) +if (sample->user_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { sz +=4 *sizeof (u64); + sz += (sample->user_regs->nr_vectors * + sample->user_regs->vector_qwords + + sample->user_regs->nr_pred * + sample->user_regs->pred_qwords) *sizeof (u64); + } result += sz; }else { result +=sizeof (u64);
@@ -1557,8 +1562,13 @@ size_t perf_event__sample_event_size(const struct perf_sample *sample, u64 type,if (sample->intr_regs && sample->intr_regs->abi) { result +=sizeof (u64); sz =hweight64 (sample->intr_regs->mask) *sizeof (u64); -if (sample->intr_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) +if (sample->intr_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { sz +=4 *sizeof (u64); + sz += (sample->intr_regs->nr_vectors * + sample->intr_regs->vector_qwords + + sample->intr_regs->nr_pred * + sample->intr_regs->pred_qwords) *sizeof (u64); + } result += sz; }else { result +=sizeof (u64);
@@ -1746,6 +1756,18 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo sz =hweight64 (sample->user_regs->mask) *sizeof (u64);memcpy (array, sample->user_regs->regs, sz); array = (void *)array + sz; +if (sample->user_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { + *array++ = sample->user_regs->nr_vectors; + *array++ = sample->user_regs->vector_qwords; + *array++ = sample->user_regs->nr_pred; + *array++ = sample->user_regs->pred_qwords; + sz = (sample->user_regs->nr_vectors * + sample->user_regs->vector_qwords + + sample->user_regs->nr_pred * + sample->user_regs->pred_qwords) *sizeof (u64); +memcpy (array, sample->user_regs->simd_data, sz); + array = (void *)array + sz; + } }else { *array++ =0 ; }
@@ -1782,6 +1804,18 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 read_fo sz =hweight64 (sample->intr_regs->mask) *sizeof (u64);memcpy (array, sample->intr_regs->regs, sz); array = (void *)array + sz; +if (sample->intr_regs->abi &PERF_SAMPLE_REGS_ABI_SIMD ) { + *array++ = sample->intr_regs->nr_vectors; + *array++ = sample->intr_regs->vector_qwords; + *array++ = sample->intr_regs->nr_pred; + *array++ = sample->intr_regs->pred_qwords; + sz = (sample->intr_regs->nr_vectors * + sample->intr_regs->vector_qwords + + sample->intr_regs->nr_pred * + sample->intr_regs->pred_qwords) *sizeof (u64); +memcpy (array, sample->intr_regs->simd_data, sz); + array = (void *)array + sz; + } }else { *array++ =0 ; }
Signature · 1 line
2.34.1
[email protected]
AI reviewRe: [Patch v9 07/10] perf regs: Enable dumping of SIMD registers
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] SIMD register decoding logic dynamically probes the host kernel, breaking cross-platform and…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] SIMD register decoding logic dynamically probes the host kernel, breaking cross-platform and offline analysis of perf.data files. --
commit 2e9a4421bef9edf42fbc7bb3efd49ba82ff3a75d
Author: Dapeng Mi <[email protected]>
perf regs: Enable dumping of SIMD registers
Support dumping of SIMD registers with the new PERF_SAMPLE_REGS_ABI_SIMD ABI.
Currently, the XMM, YMM, ZMM, OPMASK, eGPRs, and SSP registers on x86 platforms are supported with the PERF_SAMPLE_REGS_ABI_SIMD ABI.
Quoted 4 lines
tools/perf/builtin-script.c +0
-0
[ ... ]
Quoted 1 line
tools/perf/builtin-script.c +0
-0@@ -719,23 +719,96 @@ static int perf_session__check_output_opt(struct perf_session *session)
[ ... ]
tools/perf/builtin-script.c static int perf_session__check_output_opt(struct perf_session *session) · line 763
Quoted 10 lines
tools/perf/builtin-script.c +10
-0+for (reg_c =0 ; reg_c <64 ; reg_c++) { +if (!regs->nr_vectors) +break ; +if (intr) { +perf_intr_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + }else { +perf_user_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + }
[Severity: Medium]
Could this break offline and cross-platform analysis of perf.data files?
The perf_intr_simd_reg_class_bitmap_qwords() function dynamically probes the host kernel via sys_perf_event_open() to determine the SIMD register lengths.
If a user analyzes a perf.data file on a different machine lacking support for that specific SIMD ABI (such as a non-x86 architecture or an older kernel), would the probe fail and return a length of 0, causing the register names to be printed as "unknown"?
This same pattern appears in tools/perf/util/scripting-engines/trace-event-python.c and tools/perf/util/session.c.
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=7
Re: [Patch v9 07/10] perf regs: Enable dumping of SIMD registers
Quoted 38 lines · On 7/6/2026 10:55 AM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] SIMD register decoding logic dynamically probes the host kernel, breaking cross-platform and offline analysis of perf.data files. --commit
2e9a4421bef9edf42fbc7bb3efd49ba82ff3a75d
Author: Dapeng Mi <[email protected]>perf regs: Enable dumping of SIMD registers
Support dumping of SIMD registers with the new
PERF_SAMPLE_REGS_ABI_SIMDABI.Currently, the XMM, YMM, ZMM, OPMASK, eGPRs, and SSP registers on x86 platforms are supported with the
PERF_SAMPLE_REGS_ABI_SIMDABI.Quoted 4 lines
tools/perf/builtin-script.c +0
-0[ ... ]
Quoted 1 line
tools/perf/builtin-script.c +0
-0@@ -719,23 +719,96 @@ static int perf_session__check_output_opt(struct perf_session *session)[ ... ]
tools/perf/builtin-script.c static int perf_session__check_output_opt(struct perf_session *session) · line 763
Quoted 10 lines
tools/perf/builtin-script.c +10
-0+for (reg_c =0 ; reg_c <64 ; reg_c++) { +if (!regs->nr_vectors) +break ; +if (intr) { +perf_intr_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + }else { +perf_user_simd_reg_class_bitmap_qwords (e_machine, reg_c, + &qwords,/*pred=*/ false); + }[Severity: Medium]
Could this break offline and cross-platform analysis of perf.data files?The
perf_intr_simd_reg_class_bitmap_qwords()function dynamically probes the host kernel viasys_perf_event_open()to determine the SIMD register lengths.
Quoted 7 lines
If a user analyzes a perf.data file on a different machine lacking support for that specific SIMD ABI (such as a non-x86 architecture or an older kernel), would the probe fail and return a length of 0, causing the register names to be printed as "unknown"?
This same pattern appears in
tools/perf/util/scripting-engines/trace-event-python.candtools/perf/util/session.c.
It's expected. Currently SIMD register sampling doesn't support cross-arch parsing.
Quoted 1 line
PATCH v9 8/10 perf dwarf-regs: Add SIMD/eGPRs support for x86 DWARF registers
In reply to Dapeng MiEnhance the x86-specific DWARF register handling by adding support for SIMD and eGPRs registers.
This update is based on the "DWARF Register Number Mapping" table from the "System V Application Binary Interface AMD64 Architecture Processor Supplement" (version 1.0).
Modifications include:
- Updating the x86_64_regidx_table[] array to incorporate SIMD and eGPRs registers.
- Enhancing the __get_dwarf_regnum_for_perf_regnum_x86_64() function to retrieve the DWARF register index for eGPRs.
Since currently libdw doesn't support SIMD and APX eGPRs registers yet, still keep the original return value for get_libdw_frame_nregs() helper.
--- .../util/dwarf-regs-arch/dwarf-regs-x86.c | 138 +++++++++++++++--- tools/perf/util/dwarf-regs.c | 9 +- tools/perf/util/include/dwarf-regs.h | 7 +- tools/perf/util/unwind-libdw.c | 6 +- 4 files changed, 132 insertions(+), 28 deletions(-)
tools/perf/util/dwarf-regs-arch/dwarf-regs-x86.c +117 -21
@@ -90,22 +90,22 @@ static const struct dwarf_regs_idx x86_64_regidx_table[] = { { "r14", 14 }, { "r14d", 14 }, { "r14w", 14 }, { "r14b", 14 }, { "r15", 15 }, { "r15d", 15 }, { "r15w", 15 }, { "r15b", 15 },// 16 - Return Address RA - { "xmm0", 17}, - { "xmm1", 18}, - { "xmm2", 19}, - { "xmm3", 20}, - { "xmm4", 21}, - { "xmm5", 22}, - { "xmm6", 23}, - { "xmm7", 24}, - { "xmm8", 25}, - { "xmm9", 26}, - { "xmm10", 27}, - { "xmm11", 28}, - { "xmm12", 29}, - { "xmm13", 30}, - { "xmm14", 31}, - { "xmm15", 32}, + { "zmm0", 17 }, { "ymm0", 17 }, { "xmm0", 17 }, + { "zmm1", 18 }, { "ymm1", 18 }, { "xmm1", 18 }, + { "zmm2", 19 }, { "ymm2", 19 }, { "xmm2", 19 }, + { "zmm3", 20 }, { "ymm3", 20 }, { "xmm3", 20 }, + { "zmm4", 21 }, { "ymm4", 21 }, { "xmm4", 21 }, + { "zmm5", 22 }, { "ymm5", 22 }, { "xmm5", 22 }, + { "zmm6", 23 }, { "ymm6", 23 }, { "xmm6", 23 }, + { "zmm7", 24 }, { "ymm7", 24 }, { "xmm7", 24 }, + { "zmm8", 25 }, { "ymm8", 25 }, { "xmm8", 25 }, + { "zmm9", 26 }, { "ymm9", 26 }, { "xmm9", 26 }, + { "zmm10", 27 }, { "ymm10", 27 }, { "xmm10", 27 }, + { "zmm11", 28 }, { "ymm11", 28 }, { "xmm11", 28 }, + { "zmm12", 29 }, { "ymm12", 29 }, { "xmm12", 29 }, + { "zmm13", 30 }, { "ymm13", 30 }, { "xmm13", 30 }, + { "zmm14", 31 }, { "ymm14", 31 }, { "xmm14", 31 }, + { "zmm15", 32 }, { "ymm15", 32 }, { "xmm15", 32 }, { "st0", 33}, { "st1", 34}, { "st2", 35},
@@ -129,7 +129,7 @@ static const struct dwarf_regs_idx x86_64_regidx_table[] = { { "ds", 53}, { "fs", 54}, { "gs", 55}, -// 56-47 - reserved +// 56-57 - reserved { "fs.base", 58}, { "gs.base", 59},// 60-61 - reserved
@@ -138,6 +138,49 @@ static const struct dwarf_regs_idx x86_64_regidx_table[] = { { "mxcsr", 64}, // 128-bit Media Control and Status { "fcw", 65}, // x87 Control Word { "fsw", 66}, // x87 Status Word +// 67-82 - Upper Vector Registers 16–31 + { "zmm16", 67 }, { "ymm16", 67 }, { "xmm16", 67 }, + { "zmm17", 68 }, { "ymm17", 68 }, { "xmm17", 68 }, + { "zmm18", 69 }, { "ymm18", 69 }, { "xmm18", 69 }, + { "zmm19", 70 }, { "ymm19", 70 }, { "xmm19", 70 }, + { "zmm20", 71 }, { "ymm20", 71 }, { "xmm20", 71 }, + { "zmm21", 72 }, { "ymm21", 72 }, { "xmm21", 72 }, + { "zmm22", 73 }, { "ymm22", 73 }, { "xmm22", 73 }, + { "zmm23", 74 }, { "ymm23", 74 }, { "xmm23", 74 }, + { "zmm24", 75 }, { "ymm24", 75 }, { "xmm24", 75 }, + { "zmm25", 76 }, { "ymm25", 76 }, { "xmm25", 76 }, + { "zmm26", 77 }, { "ymm26", 77 }, { "xmm26", 77 }, + { "zmm27", 78 }, { "ymm27", 78 }, { "xmm27", 78 }, + { "zmm28", 79 }, { "ymm28", 79 }, { "xmm28", 79 }, + { "zmm29", 80 }, { "ymm29", 80 }, { "xmm29", 80 }, + { "zmm30", 81 }, { "ymm30", 81 }, { "xmm30", 81 }, + { "zmm31", 82 }, { "ymm31", 82 }, { "xmm31", 82 }, +// 118-125 - Vector Mask Registers 0–7 + { "k0", 118 }, + { "k1", 119 }, + { "k2", 120 }, + { "k3", 121 }, + { "k4", 122 }, + { "k5", 123 }, + { "k6", 124 }, + { "k7", 125 }, +// 130-145 - APX Integer Registers 16-31 + { "r16", 130 }, { "r16d", 130 }, { "r16w", 130 }, { "r16b", 130 }, + { "r17", 131 }, { "r17d", 131 }, { "r17w", 131 }, { "r17b", 131 }, + { "r18", 132 }, { "r18d", 132 }, { "r18w", 132 }, { "r18b", 132 }, + { "r19", 133 }, { "r19d", 133 }, { "r19w", 133 }, { "r19b", 133 }, + { "r20", 134 }, { "r20d", 134 }, { "r20w", 134 }, { "r20b", 134 }, + { "r21", 135 }, { "r21d", 135 }, { "r21w", 135 }, { "r21b", 135 }, + { "r22", 136 }, { "r22d", 136 }, { "r22w", 136 }, { "r22b", 136 }, + { "r23", 137 }, { "r23d", 137 }, { "r23w", 137 }, { "r23b", 137 }, + { "r24", 138 }, { "r24d", 138 }, { "r24w", 138 }, { "r24b", 138 }, + { "r25", 139 }, { "r25d", 139 }, { "r25w", 139 }, { "r25b", 139 }, + { "r26", 140 }, { "r26d", 140 }, { "r26w", 140 }, { "r26b", 140 }, + { "r27", 141 }, { "r27d", 141 }, { "r27w", 141 }, { "r27b", 141 }, + { "r28", 142 }, { "r28d", 142 }, { "r28w", 142 }, { "r28b", 142 }, + { "r29", 143 }, { "r29d", 143 }, { "r29w", 143 }, { "r29b", 143 }, + { "r30", 144 }, { "r30d", 144 }, { "r30w", 144 }, { "r30b", 144 }, + { "r31", 145 }, { "r31d", 145 }, { "r31w", 145 }, { "r31b", 145 },// End of regular dwarf registers. { "rip", DWARF_REG_PC }, { "eip", DWARF_REG_PC }, { "ip", DWARF_REG_PC }, };
@@ -204,7 +247,7 @@ int __get_dwarf_regnum_for_perf_regnum_i386(int perf_regnum)return dwarf_i386_regnums[perf_regnum]; } -int __get_dwarf_regnum_for_perf_regnum_x86_64 (int perf_regnum) +int __get_dwarf_regnum_for_perf_regnum_x86_64 (int perf_regnum,int abi) {static const int dwarf_x86_64_regnums[] = { [PERF_REG_X86_AX ] =0 ,
@@ -248,13 +291,66 @@ int __get_dwarf_regnum_for_perf_regnum_x86_64(int perf_regnum) [PERF_REG_X86_XMM14] = 31, [PERF_REG_X86_XMM15] = 32, }; +static const int dwarf_x86_64_regnums_apx[] = { + [PERF_REG_X86_AX ] =0 , + [PERF_REG_X86_BX ] =3 , + [PERF_REG_X86_CX ] =2 , + [PERF_REG_X86_DX ] =1 , + [PERF_REG_X86_SI ] =4 , + [PERF_REG_X86_DI ] =5 , + [PERF_REG_X86_BP ] =6 , + [PERF_REG_X86_SP ] =7 , + [PERF_REG_X86_IP ] =16 , + [PERF_REG_X86_FLAGS ] =49 , + [PERF_REG_X86_CS ] =51 , + [PERF_REG_X86_SS ] =52 , + [PERF_REG_X86_DS ] =53 , + [PERF_REG_X86_ES ] =50 , + [PERF_REG_X86_FS ] =54 , + [PERF_REG_X86_GS ] =55 , + [PERF_REG_X86_R8 ] =8 , + [PERF_REG_X86_R9 ] =9 , + [PERF_REG_X86_R10 ] =10 , + [PERF_REG_X86_R11 ] =11 , + [PERF_REG_X86_R12 ] =12 , + [PERF_REG_X86_R13 ] =13 , + [PERF_REG_X86_R14 ] =14 , + [PERF_REG_X86_R15 ] =15 , + [PERF_REG_X86_R16 ] =130 , + [PERF_REG_X86_R17 ] =131 , + [PERF_REG_X86_R18 ] =132 , + [PERF_REG_X86_R19 ] =133 , + [PERF_REG_X86_R20 ] =134 , + [PERF_REG_X86_R21 ] =135 , + [PERF_REG_X86_R22 ] =136 , + [PERF_REG_X86_R23 ] =137 , + [PERF_REG_X86_R24 ] =138 , + [PERF_REG_X86_R25 ] =139 , + [PERF_REG_X86_R26 ] =140 , + [PERF_REG_X86_R27 ] =141 , + [PERF_REG_X86_R28 ] =142 , + [PERF_REG_X86_R29 ] =143 , + [PERF_REG_X86_R30 ] =144 , + [PERF_REG_X86_R31 ] =145 , + };if (perf_regnum ==0 )return 0 ; -if (perf_regnum <0 || perf_regnum >= (int )ARRAY_SIZE (dwarf_x86_64_regnums) || - dwarf_x86_64_regnums[perf_regnum] ==0 ) +if (perf_regnum <0 ) +return -ENOENT ; + +if (!(abi &PERF_SAMPLE_REGS_ABI_SIMD ) && + (perf_regnum >= (int )ARRAY_SIZE (dwarf_x86_64_regnums) || + dwarf_x86_64_regnums[perf_regnum] ==0 )) +return -ENOENT ; + +if ((abi &PERF_SAMPLE_REGS_ABI_SIMD ) && + (perf_regnum >= (int )ARRAY_SIZE (dwarf_x86_64_regnums_apx) || + dwarf_x86_64_regnums_apx[perf_regnum] ==0 ))return -ENOENT ; -return dwarf_x86_64_regnums[perf_regnum]; +return abi &PERF_SAMPLE_REGS_ABI_SIMD ? + dwarf_x86_64_regnums_apx[perf_regnum] : + dwarf_x86_64_regnums[perf_regnum]; }
tools/perf/util/dwarf-regs.c +7 -2
@@ -158,6 +158,10 @@ static int get_libdw_frame_nregs(unsigned int machine, unsigned int flags __mayb {switch (machine) {case EM_X86_64 : +/* +* Since libdw doesn't support SIMD and APX eGPR register yet, +* still keep nregs to 17. +*/ return 17 ;case EM_386 :return 9 ;
@@ -187,13 +191,14 @@ static int get_libdw_frame_nregs(unsigned int machine, unsigned int flags __mayb }int get_dwarf_regnum_for_perf_regnum (int perf_regnum,unsigned int machine, -unsigned int flags,bool only_libdw_supported) +unsigned int flags, +bool only_libdw_supported,int abi) {int reg;switch (machine) {case EM_X86_64 : - reg =__get_dwarf_regnum_for_perf_regnum_x86_64 (perf_regnum); + reg =__get_dwarf_regnum_for_perf_regnum_x86_64 (perf_regnum, abi);break ;case EM_386 : reg =__get_dwarf_regnum_for_perf_regnum_i386 (perf_regnum);
tools/perf/util/include/dwarf-regs.h +4 -3
@@ -103,7 +103,7 @@ int __get_csky_regnum(const char *name, unsigned int flags);int __get_dwarf_regnum_i386 (const char *name);int __get_dwarf_regnum_x86_64 (const char *name);int __get_dwarf_regnum_for_perf_regnum_i386 (int perf_regnum); -int __get_dwarf_regnum_for_perf_regnum_x86_64 (int perf_regnum); +int __get_dwarf_regnum_for_perf_regnum_x86_64 (int perf_regnum,int abi);int __get_dwarf_regnum_for_perf_regnum_arm (int perf_regnum);int __get_dwarf_regnum_for_perf_regnum_arm64 (int perf_regnum);
@@ -125,8 +125,9 @@ int get_dwarf_regnum(const char *name, unsigned int machine, unsigned int flags)/* * get_dwarf_regnum - Returns DWARF regnum from perf register number. */ -int get_dwarf_regnum_for_perf_regnum (int perf_regnum,unsigned int machine,unsigned int flags, -bool only_libdw_supported); +int get_dwarf_regnum_for_perf_regnum (int perf_regnum,unsigned int machine, +unsigned int flags, +bool only_libdw_supported,int abi);void get_powerpc_regs (u32 raw_insn,int is_source,struct annotated_op_loc *op_loc);
tools/perf/util/unwind-libdw.c +4 -2
@@ -273,7 +273,8 @@ static bool libdw_set_initial_registers(Dwfl_Thread *thread, void *arg)int dwarf_reg =get_dwarf_regnum_for_perf_regnum (perf_reg, e_machine, e_flags, -/*only_libdw_supported=*/ true); +/*only_libdw_supported=*/ true, + user_regs->abi);if (dwarf_reg > max_dwarf_reg) max_dwarf_reg = dwarf_reg; }
@@ -288,7 +289,8 @@ static bool libdw_set_initial_registers(Dwfl_Thread *thread, void *arg)int dwarf_reg =get_dwarf_regnum_for_perf_regnum (perf_reg, e_machine, e_flags, -/*only_libdw_supported=*/ true); +/*only_libdw_supported=*/ true, + user_regs->abi);if (dwarf_reg >=0 ) { val =0 ;if (perf_reg_value (&val, user_regs, perf_reg) ==0 )
Signature · 1 line
2.34.1
PATCH v9 9/10 perf tests: Add x86 eGPRs/SSP registers sampling test
In reply to Dapeng MiValidate that eGPRs (extended general purpose registers) and SSP (shadow stack pointer) registers can be sampled correctly on x86 platforms with hardware support.
--- tools/perf/tests/shell/record.sh | 126 +++++++++++++++++++++++++++++++ 1 file changed, 126 insertions(+)
tools/perf/tests/shell/record.sh +126 -0
@@ -131,6 +131,131 @@ check_system_wide() { perf report -i "${perfdata}" -q | grep -q "${testsym}" } +has_required_regs() { + local regs_output="$1" + shift + + for reg in "$@" + do + if ! echo "${regs_output}" | grep -q -i "${reg}" + then + return 1 + fi + done + + return 0 +} + +validate_gp_reg_sampling() { + local regs_opt="$1" + local regs_value="$2" + local script_field="$3" + local sample_output + shift 3 + + if ! sample_output=$(perf record -o - "${regs_opt}=${regs_value}" \ + -e br_inst_retired.near_call -c 1000 --per-thread ${testprog} 2> /dev/null \ + | perf script -F ip,sym,"${script_field}" -i - 2> /dev/null) + then + return 1 + fi + + if ! has_required_regs "${sample_output}" "$@" + then + return 1 + fi + + return 0 +} + +test_egpr_register_capture() { + local arch + local intr_regs + local user_regs + local tested=0 + + echo "eGPR/SSP register capture test" + + arch=$(uname -m) + case ${arch} in + x86_64|i386) + ;; + *) + echo "eGPR/SSP register capture test [Skipped non-x86 platform]" + return + ;; + esac + + if ! perf list pmu | grep -q 'br_inst_retired.near_call' + then + echo "eGPR/SSP register capture test [Skipped missing event]" + return + fi + + intr_regs=$(perf record --intr-regs=\? 2>&1 || true) + user_regs=$(perf record --user-regs=\? 2>&1 || true) + + if has_required_regs "${intr_regs}" R16 R31 + then + if ! validate_gp_reg_sampling "--intr-regs" "r16,r31" "iregs" "R16:" "R31:" + then + echo "eGPR/SSP register capture test [Failed eGPR intr-regs validation]" + err=1 + return + fi + tested=1 + else + echo "eGPR/SSP register capture test [Skipped missing eGPR intr-regs (R16/R31)]" + fi + + if has_required_regs "${user_regs}" R16 R31 + then + if ! validate_gp_reg_sampling "--user-regs" "r16,r31" "uregs" "R16:" "R31:" + then + echo "eGPR/SSP register capture test [Failed eGPR user-regs validation]" + err=1 + return + fi + tested=1 + else + echo "eGPR/SSP register capture test [Skipped missing eGPR user-regs (R16/R31)]" + fi + + if has_required_regs "${intr_regs}" SSP + then + if ! validate_gp_reg_sampling "--intr-regs" "ssp" "iregs" "SSP:" + then + echo "eGPR/SSP register capture test [Failed SSP intr-regs validation]" + err=1 + return + fi + tested=1 + else + echo "eGPR/SSP register capture test [Skipped missing SSP intr-regs]" + fi + + if has_required_regs "${user_regs}" SSP + then + if ! validate_gp_reg_sampling "--user-regs" "ssp" "uregs" "SSP:" + then + echo "eGPR/SSP register capture test [Failed SSP user-regs validation]" + err=1 + return + fi + tested=1 + else + echo "eGPR/SSP register capture test [Skipped missing SSP user-regs]" + fi + + if [ ${tested} -eq 0 ] + then + echo "eGPR/SSP register capture test [Skipped missing eGPR/SSP registers]" + return + fi + + echo "eGPR/SSP register capture test [Success]" +} + test_system_wide() { echo "Basic --system-wide mode test" local ret=0
@@ -449,6 +574,7 @@ fi test_per_thread test_register_capture +test_egpr_register_capture test_system_wide test_workload test_branch_counter
Signature · 1 line
2.34.1
[email protected]
AI reviewRe: [Patch v9 09/10] perf tests: Add x86 eGPRs/SSP registers sampling test
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] The validation function `validate_gp_reg_sampling` executes a single hardcoded `perf record`…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The validation function validate_gp_reg_sampling executes a single hardcoded perf record pipeline instead of using the standard perf_record_with_retry helper, leading to test flakiness and untraceable failures. --
commit 5bc6b87aa83194eef4aff3394561f1bdb19039e4
Author: Dapeng Mi <[email protected]>
perf tests: Add x86 eGPRs/SSP registers sampling test
Validate that eGPRs (extended general purpose registers) and SSP (shadow stack pointer) registers can be sampled correctly on x86 platforms with hardware support.
Quoted 4 lines
tools/perf/tests/shell/record.sh +0
-0
[ ... ]
tools/perf/tests/shell/record.sh check_system_wide() { · line 140
Quoted 11 lines
tools/perf/tests/shell/record.sh +10
-0@@ -131,6 +131,131 @@ check_system_wide() { +validate_gp_reg_sampling() { + local regs_opt="$1" + local regs_value="$2" + local script_field="$3" + local sample_output + shift 3 + + if ! sample_output=$(perf record -o - "${regs_opt}=${regs_value}" \ + -e br_inst_retired.near_call -c 1000 --per-thread ${testprog} 2> /dev/null \ + | perf script -F ip,sym,"${script_field}" -i - 2> /dev/null)
[Severity: Medium]
Could this hardcoded perf record pipeline lead to test flakiness on slower environments?
By not using the standard perf_record_with_retry helper, a single execution might fail to generate the 1000 near calls required to trigger a hardware sample.
Additionally, does suppressing stderr with 2> /dev/null permanently hide error details from the CI pipelines by bypassing the PERF_RECORD_LOGS collection mechanism?
Quoted 11 lines
tools/perf/tests/shell/record.sh +11
-0+ then + return 1 + fi + + if ! has_required_regs "${sample_output}" "$@" + then + return 1 + fi + + return 0 +}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=9
Re: [Patch v9 09/10] perf tests: Add x86 eGPRs/SSP registers sampling test
Quoted 34 lines · On 7/6/2026 11:00 AM, [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] The validation functionvalidate_gp_reg_samplingexecutes a single hardcodedperf recordpipeline instead of using the standardperf_record_with_retryhelper, leading to test flakiness and untraceable failures. --commit
5bc6b87aa83194eef4aff3394561f1bdb19039e4
Author: Dapeng Mi <[email protected]>perf tests: Add x86 eGPRs/SSP registers sampling test
Validate that eGPRs (extended general purpose registers) and SSP (shadow stack pointer) registers can be sampled correctly on x86 platforms with hardware support.
Quoted 4 lines
tools/perf/tests/shell/record.sh +0
-0[ ... ]
tools/perf/tests/shell/record.sh check_system_wide() { · line 140
Quoted 11 lines
tools/perf/tests/shell/record.sh +10
-0@@ -131,6 +131,131 @@ check_system_wide() { +validate_gp_reg_sampling() { + local regs_opt="$1" + local regs_value="$2" + local script_field="$3" + local sample_output + shift 3 + + if ! sample_output=$(perf record -o - "${regs_opt}=${regs_value}" \ + -e br_inst_retired.near_call -c 1000 --per-thread ${testprog} 2> /dev/null \ + | perf script -F ip,sym,"${script_field}" -i - 2> /dev/null)[Severity: Medium]
Could this hardcoded perf record pipeline lead to test flakiness on slower environments?
Quoted 7 lines
By not using the standard
perf_record_with_retryhelper, a single execution might fail to generate the 1000 near calls required to trigger a hardware sample.Additionally, does suppressing stderr with 2>
/dev/nullpermanently hide error details from the CI pipelines by bypassing thePERF_RECORD_LOGScollection mechanism?
This comment seems a false positive. There is no perf_record_with_retry helper in kernel code base.
Quoted 12 lines
Quoted 12 lines
tools/perf/tests/shell/record.sh +11
-0+ then + return 1 + fi + + if ! has_required_regs "${sample_output}" "$@" + then + return 1 + fi + + return 0 +}
PATCH v9 10/10 perf tests: Add SIMD registers sampling test
In reply to Dapeng MiValidate that SIMD registers (XMM/YMM/ZMM on x86) can be sampled correctly with hardware support.
--- tools/perf/tests/shell/record.sh | 131 +++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+)
tools/perf/tests/shell/record.sh +131 -0
@@ -256,6 +256,136 @@ test_egpr_register_capture() { echo "eGPR/SSP register capture test [Success]" } +extract_x86_advertised_simd_classes() { + local regs_output="$1" + + echo "${regs_output}" \ + | grep -oE '(ZMM|YMM|XMM|OPMASK)[0-9]+-[0-9]+' \ + | sed -E 's/[0-9]+-[0-9]+$//' \ + | tr '[:upper:]' '[:lower:]' \ + | sort -u +} + +ordered_x86_simd_classes() { + local advertised_classes="$1" + local simd_classes="" + + if echo "${advertised_classes}" | grep -qw zmm + then + simd_classes="${simd_classes} zmm" + fi + if echo "${advertised_classes}" | grep -qw ymm + then + simd_classes="${simd_classes} ymm" + fi + if echo "${advertised_classes}" | grep -qw xmm + then + simd_classes="${simd_classes} xmm" + fi + if echo "${advertised_classes}" | grep -qw opmask + then + simd_classes="${simd_classes} opmask" + fi + + echo "${simd_classes}" | xargs +} + +validate_simd_sampling_mode() { + local regs_opt="$1" + local simd_classes="$2" + local script_field="$3" + local simd_class + local sample_output + + for simd_class in ${simd_classes} + do + if ! sample_output=$(perf record -o - "${regs_opt}=${simd_class}" \ + -e br_inst_retired.near_call -c 1000 --per-thread ${testprog} 2> /dev/null \ + | perf script -F ip,sym,"${script_field}" -i - 2> /dev/null) + then + echo "SIMD register capture test [Failed record ${regs_opt}=${simd_class}]" + return 1 + fi + + if ! has_required_regs "${sample_output}" "${simd_class}" + then + echo "SIMD register capture test [Failed missing ${simd_class} sampling data]" + return 1 + fi + done + + return 0 +} + +test_simd_register_capture() { + local arch + local intr_regs + local user_regs + local simd_classes + local user_simd_classes + local advertised_intr_classes + local advertised_user_classes + local tested=0 + + echo "SIMD register capture test" + if ! perf list pmu | grep -q 'br_inst_retired.near_call' + then + echo "SIMD register capture test [Skipped missing event]" + return + fi + + intr_regs=$(perf record --intr-regs=\? 2>&1 || true) + user_regs=$(perf record --user-regs=\? 2>&1 || true) + + simd_classes="" + user_simd_classes="" + + arch=$(uname -m) + case ${arch} in + x86_64|i386) + advertised_intr_classes=$(extract_x86_advertised_simd_classes "${intr_regs}") + advertised_user_classes=$(extract_x86_advertised_simd_classes "${user_regs}") + + simd_classes=$(ordered_x86_simd_classes "${advertised_intr_classes}") + user_simd_classes=$(ordered_x86_simd_classes "${advertised_user_classes}") + ;; + *) + ;; + esac + + if [ -z "${simd_classes}" ] + then + echo "SIMD register capture test [Skipped missing intr SIMD registers]" + elif ! validate_simd_sampling_mode "--intr-regs" "${simd_classes}" "iregs" + then + echo "SIMD register capture test [Failed missing intr SIMD register sampling data]" + err=1 + return + else + tested=1 + fi + + if [ -z "${user_simd_classes}" ] + then + echo "SIMD register capture test [Skipped missing user SIMD registers]" + elif ! validate_simd_sampling_mode "--user-regs" "${user_simd_classes}" "uregs" + then + echo "SIMD register capture test [Failed missing user SIMD register sampling data]" + err=1 + return + else + tested=1 + fi + + if [ ${tested} -eq 0 ] + then + echo "SIMD register capture test [Skipped missing SIMD registers]" + return + fi + + echo "SIMD register capture test [Success]" +} + test_system_wide() { echo "Basic --system-wide mode test" local ret=0
@@ -575,6 +705,7 @@ fi test_per_thread test_register_capture test_egpr_register_capture +test_simd_register_capture test_system_wide test_workload test_branch_counter
Signature · 1 line
2.34.1