294 lines · c
1//===-- LinuxPTraceDefines_arm64sve.h ------------------------- -*- C++ -*-===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPTRACEDEFINES_ARM64SVE_H10#define LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPTRACEDEFINES_ARM64SVE_H11 12#include <cstdint>13 14namespace lldb_private {15namespace sve {16 17/*18 * The SVE architecture leaves space for future expansion of the19 * vector length beyond its initial architectural limit of 2048 bits20 * (16 quadwords).21 *22 * See <Linux kernel source tree>/Documentation/arm64/sve.rst for a description23 * of the vl/vq terminology.24 */25 26const uint16_t vq_bytes = 16; /* number of bytes per quadword */27 28const uint16_t vq_min = 1;29const uint16_t vq_max = 512;30 31const uint16_t vl_min = vq_min * vq_bytes;32const uint16_t vl_max = vq_max * vq_bytes;33 34const uint16_t num_of_zregs = 32;35const uint16_t num_of_pregs = 16;36 37inline uint16_t vl_valid(uint16_t vl) {38 return (vl % vq_bytes == 0 && vl >= vl_min && vl <= vl_max);39}40 41inline uint16_t vq_from_vl(uint16_t vl) { return vl / vq_bytes; }42inline uint16_t vl_from_vq(uint16_t vq) { return vq * vq_bytes; }43 44/* A new signal frame record sve_context encodes the SVE Registers on signal45 * delivery. sve_context struct definition may be included in asm/sigcontext.h.46 * We define sve_context_size which will be used by LLDB sve helper functions.47 * More information on sve_context can be found in Linux kernel source tree at48 * Documentation/arm64/sve.rst.49 */50 51const uint16_t sve_context_size = 16;52 53/*54 * If the SVE registers are currently live for the thread at signal delivery,55 * sve_context.head.size >=56 * SigContextSize(vq_from_vl(sve_context.vl))57 * and the register data may be accessed using the Sig*() functions.58 *59 * If sve_context.head.size <60 * SigContextSize(vq_from_vl(sve_context.vl)),61 * the SVE registers were not live for the thread and no register data62 * is included: in this case, the Sig*() functions should not be63 * used except for this check.64 *65 * The same convention applies when returning from a signal: a caller66 * will need to remove or resize the sve_context block if it wants to67 * make the SVE registers live when they were previously non-live or68 * vice-versa. This may require the caller to allocate fresh69 * memory and/or move other context blocks in the signal frame.70 *71 * Changing the vector length during signal return is not permitted:72 * sve_context.vl must equal the thread's current vector length when73 * doing a sigreturn.74 *75 *76 * Note: for all these functions, the "vq" argument denotes the SVE77 * vector length in quadwords (i.e., units of 128 bits).78 *79 * The correct way to obtain vq is to use vq_from_vl(vl). The80 * result is valid if and only if vl_valid(vl) is true. This is81 * guaranteed for a struct sve_context written by the kernel.82 *83 *84 * Additional functions describe the contents and layout of the payload.85 * For each, Sig*Offset(args) is the start offset relative to86 * the start of struct sve_context, and Sig*Size(args) is the87 * size in bytes:88 *89 * x type description90 * - ---- -----------91 * REGS the entire SVE context92 *93 * ZREGS __uint128_t[num_of_zregs][vq] all Z-registers94 * ZREG __uint128_t[vq] individual Z-register Zn95 *96 * PREGS uint16_t[num_of_pregs][vq] all P-registers97 * PREG uint16_t[vq] individual P-register Pn98 *99 * FFR uint16_t[vq] first-fault status register100 *101 * Additional data might be appended in the future.102 */103 104inline uint16_t SigZRegSize(uint16_t vq) { return vq * vq_bytes; }105inline uint16_t SigPRegSize(uint16_t vq) { return vq * vq_bytes / 8; }106inline uint16_t SigFFRSize(uint16_t vq) { return SigPRegSize(vq); }107 108inline uint32_t SigRegsOffset() {109 return (sve_context_size + vq_bytes - 1) / vq_bytes * vq_bytes;110}111 112inline uint32_t SigZRegsOffset() { return SigRegsOffset(); }113 114inline uint32_t SigZRegOffset(uint16_t vq, uint16_t n) {115 return SigRegsOffset() + SigZRegSize(vq) * n;116}117 118inline uint32_t SigZRegsSize(uint16_t vq) {119 return SigZRegOffset(vq, num_of_zregs) - SigRegsOffset();120}121 122inline uint32_t SigPRegsOffset(uint16_t vq) {123 return SigRegsOffset() + SigZRegsSize(vq);124}125 126inline uint32_t SigPRegOffset(uint16_t vq, uint16_t n) {127 return SigPRegsOffset(vq) + SigPRegSize(vq) * n;128}129 130inline uint32_t SigpRegsSize(uint16_t vq) {131 return SigPRegOffset(vq, num_of_pregs) - SigPRegsOffset(vq);132}133 134inline uint32_t SigFFROffset(uint16_t vq) {135 return SigPRegsOffset(vq) + SigpRegsSize(vq);136}137 138inline uint32_t SigRegsSize(uint16_t vq) {139 return SigFFROffset(vq) + SigFFRSize(vq) - SigRegsOffset();140}141 142inline uint32_t SVESigContextSize(uint16_t vq) {143 return SigRegsOffset() + SigRegsSize(vq);144}145 146struct user_sve_header {147 uint32_t size; /* total meaningful regset content in bytes */148 uint32_t max_size; /* maxmium possible size for this thread */149 uint16_t vl; /* current vector length */150 uint16_t max_vl; /* maximum possible vector length */151 uint16_t flags;152 uint16_t reserved;153};154 155using user_za_header = user_sve_header;156 157/* Definitions for user_sve_header.flags: */158const uint16_t ptrace_regs_mask = 1 << 0;159const uint16_t ptrace_regs_fpsimd = 0;160const uint16_t ptrace_regs_sve = ptrace_regs_mask;161 162/*163 * The remainder of the SVE state follows struct user_sve_header. The164 * total size of the SVE state (including header) depends on the165 * metadata in the header: PTraceSize(vq, flags) gives the total size166 * of the state in bytes, including the header.167 *168 * Refer to <asm/sigcontext.h> for details of how to pass the correct169 * "vq" argument to these macros.170 */171 172/* Offset from the start of struct user_sve_header to the register data */173inline uint16_t PTraceRegsOffset() {174 return (sizeof(struct user_sve_header) + vq_bytes - 1) / vq_bytes * vq_bytes;175}176 177/*178 * The register data content and layout depends on the value of the179 * flags field.180 */181 182/*183 * (flags & ptrace_regs_mask) == ptrace_regs_fpsimd case:184 *185 * The payload starts at offset PTraceFPSIMDOffset, and is of type186 * struct user_fpsimd_state. Additional data might be appended in the187 * future: use PTraceFPSIMDSize(vq, flags) to compute the total size.188 * PTraceFPSIMDSize(vq, flags) will never be less than189 * sizeof(struct user_fpsimd_state).190 */191 192const uint32_t ptrace_fpsimd_offset = PTraceRegsOffset();193 194/* Return size of struct user_fpsimd_state from asm/ptrace.h */195inline uint32_t PTraceFPSIMDSize(uint16_t vq, uint16_t flags) { return 528; }196 197/*198 * (flags & ptrace_regs_mask) == ptrace_regs_sve case:199 *200 * The payload starts at offset PTraceSVEOffset, and is of size201 * PTraceSVESize(vq, flags).202 *203 * Additional functions describe the contents and layout of the payload.204 * For each, PTrace*X*Offset(args) is the start offset relative to205 * the start of struct user_sve_header, and PTrace*X*Size(args) is206 * the size in bytes:207 *208 * x type description209 * - ---- -----------210 * ZREGS \211 * ZREG |212 * PREGS | refer to <asm/sigcontext.h>213 * PREG |214 * FFR /215 *216 * FPSR uint32_t FPSR217 * FPCR uint32_t FPCR218 *219 * Additional data might be appended in the future.220 */221 222inline uint32_t PTraceZRegSize(uint16_t vq) { return SigZRegSize(vq); }223 224inline uint32_t PTracePRegSize(uint16_t vq) { return SigPRegSize(vq); }225 226inline uint32_t PTraceFFRSize(uint16_t vq) { return SigFFRSize(vq); }227 228const uint32_t fpsr_size = sizeof(uint32_t);229const uint32_t fpcr_size = sizeof(uint32_t);230 231inline uint32_t SigToPTrace(uint32_t offset) {232 return offset - SigRegsOffset() + PTraceRegsOffset();233}234 235const uint32_t ptrace_sve_offset = PTraceRegsOffset();236 237inline uint32_t PTraceZRegsOffset(uint16_t vq) {238 return SigToPTrace(SigZRegsOffset());239}240 241inline uint32_t PTraceZRegOffset(uint16_t vq, uint16_t n) {242 return SigToPTrace(SigZRegOffset(vq, n));243}244 245inline uint32_t PTraceZRegsSize(uint16_t vq) {246 return PTraceZRegOffset(vq, num_of_zregs) - SigToPTrace(SigRegsOffset());247}248 249inline uint32_t PTracePRegsOffset(uint16_t vq) {250 return SigToPTrace(SigPRegsOffset(vq));251}252 253inline uint32_t PTracePRegOffset(uint16_t vq, uint16_t n) {254 return SigToPTrace(SigPRegOffset(vq, n));255}256 257inline uint32_t PTracePRegsSize(uint16_t vq) {258 return PTracePRegOffset(vq, num_of_pregs) - PTracePRegsOffset(vq);259}260 261inline uint32_t PTraceFFROffset(uint16_t vq) {262 return SigToPTrace(SigFFROffset(vq));263}264 265inline uint32_t PTraceFPSROffset(uint16_t vq) {266 return (PTraceFFROffset(vq) + PTraceFFRSize(vq) + (vq_bytes - 1)) / vq_bytes *267 vq_bytes;268}269 270inline uint32_t PTraceFPCROffset(uint16_t vq) {271 return PTraceFPSROffset(vq) + fpsr_size;272}273 274/*275 * Any future extension appended after FPCR must be aligned to the next276 * 128-bit boundary.277 */278 279inline uint32_t PTraceSVESize(uint16_t vq, uint16_t flags) {280 return (PTraceFPCROffset(vq) + fpcr_size - ptrace_sve_offset + vq_bytes - 1) /281 vq_bytes * vq_bytes;282}283 284inline uint32_t PTraceSize(uint16_t vq, uint16_t flags) {285 return (flags & ptrace_regs_mask) == ptrace_regs_sve286 ? ptrace_sve_offset + PTraceSVESize(vq, flags)287 : ptrace_fpsimd_offset + PTraceFPSIMDSize(vq, flags);288}289 290} // namespace SVE291} // namespace lldb_private292 293#endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_LINUXPTRACEDEFINES_ARM64SVE_H294