1 //===-- RegisterInfoPOSIX_arm64.cpp ---------------------------------------===// 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-exception 6 // 7 //===---------------------------------------------------------------------===// 8 9 #include <cassert> 10 #include <cstddef> 11 #include <vector> 12 13 #include "lldb/lldb-defines.h" 14 #include "llvm/Support/Compiler.h" 15 16 #include "RegisterInfoPOSIX_arm64.h" 17 18 // Based on RegisterContextDarwin_arm64.cpp 19 #define GPR_OFFSET(idx) ((idx)*8) 20 #define GPR_OFFSET_NAME(reg) \ 21 (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::GPR, reg)) 22 23 #define FPU_OFFSET(idx) ((idx)*16 + sizeof(RegisterInfoPOSIX_arm64::GPR)) 24 #define FPU_OFFSET_NAME(reg) \ 25 (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::FPU, reg) + \ 26 sizeof(RegisterInfoPOSIX_arm64::GPR)) 27 28 // This information is based on AArch64 with SVE architecture reference manual. 29 // AArch64 with SVE has 32 Z and 16 P vector registers. There is also an FFR 30 // (First Fault) register and a VG (Vector Granule) pseudo register. 31 32 // SVE 16-byte quad word is the basic unit of expansion in vector length. 33 #define SVE_QUAD_WORD_BYTES 16 34 35 // Vector length is the multiplier which decides the no of quad words, 36 // (multiples of 128-bits or 16-bytes) present in a Z register. Vector length 37 // is decided during execution and can change at runtime. SVE AArch64 register 38 // infos have modes one for each valid value of vector length. A change in 39 // vector length requires register context to update sizes of SVE Z, P and FFR. 40 // Also register context needs to update byte offsets of all registers affected 41 // by the change in vector length. 42 #define SVE_REGS_DEFAULT_OFFSET_LINUX sizeof(RegisterInfoPOSIX_arm64::GPR) 43 44 #define SVE_OFFSET_VG SVE_REGS_DEFAULT_OFFSET_LINUX 45 46 #define EXC_OFFSET_NAME(reg) \ 47 (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::EXC, reg) + \ 48 sizeof(RegisterInfoPOSIX_arm64::GPR) + \ 49 sizeof(RegisterInfoPOSIX_arm64::FPU)) 50 #define DBG_OFFSET_NAME(reg) \ 51 (LLVM_EXTENSION offsetof(RegisterInfoPOSIX_arm64::DBG, reg) + \ 52 sizeof(RegisterInfoPOSIX_arm64::GPR) + \ 53 sizeof(RegisterInfoPOSIX_arm64::FPU) + \ 54 sizeof(RegisterInfoPOSIX_arm64::EXC)) 55 56 #define DEFINE_DBG(reg, i) \ 57 #reg, NULL, \ 58 sizeof(((RegisterInfoPOSIX_arm64::DBG *) NULL)->reg[i]), \ 59 DBG_OFFSET_NAME(reg[i]), lldb::eEncodingUint, lldb::eFormatHex, \ 60 {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \ 61 LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, \ 62 dbg_##reg##i }, \ 63 NULL, NULL, NULL, 64 #define REG_CONTEXT_SIZE \ 65 (sizeof(RegisterInfoPOSIX_arm64::GPR) + \ 66 sizeof(RegisterInfoPOSIX_arm64::FPU) + \ 67 sizeof(RegisterInfoPOSIX_arm64::EXC)) 68 69 // Include RegisterInfos_arm64 to declare our g_register_infos_arm64 structure. 70 #define DECLARE_REGISTER_INFOS_ARM64_STRUCT 71 #include "RegisterInfos_arm64.h" 72 #include "RegisterInfos_arm64_sve.h" 73 #undef DECLARE_REGISTER_INFOS_ARM64_STRUCT 74 75 static lldb_private::RegisterInfo g_register_infos_pauth[] = { 76 DEFINE_EXTENSION_REG(data_mask), DEFINE_EXTENSION_REG(code_mask)}; 77 78 static lldb_private::RegisterInfo g_register_infos_mte[] = { 79 DEFINE_EXTENSION_REG(mte_ctrl)}; 80 81 static lldb_private::RegisterInfo g_register_infos_tls[] = { 82 DEFINE_EXTENSION_REG(tpidr)}; 83 84 // Number of register sets provided by this context. 85 enum { 86 k_num_gpr_registers = gpr_w28 - gpr_x0 + 1, 87 k_num_fpr_registers = fpu_fpcr - fpu_v0 + 1, 88 k_num_sve_registers = sve_ffr - sve_vg + 1, 89 k_num_mte_register = 1, 90 k_num_tls_register = 1, 91 k_num_pauth_register = 2, 92 k_num_register_sets_default = 2, 93 k_num_register_sets = 3 94 }; 95 96 // ARM64 general purpose registers. 97 static const uint32_t g_gpr_regnums_arm64[] = { 98 gpr_x0, gpr_x1, gpr_x2, gpr_x3, 99 gpr_x4, gpr_x5, gpr_x6, gpr_x7, 100 gpr_x8, gpr_x9, gpr_x10, gpr_x11, 101 gpr_x12, gpr_x13, gpr_x14, gpr_x15, 102 gpr_x16, gpr_x17, gpr_x18, gpr_x19, 103 gpr_x20, gpr_x21, gpr_x22, gpr_x23, 104 gpr_x24, gpr_x25, gpr_x26, gpr_x27, 105 gpr_x28, gpr_fp, gpr_lr, gpr_sp, 106 gpr_pc, gpr_cpsr, gpr_w0, gpr_w1, 107 gpr_w2, gpr_w3, gpr_w4, gpr_w5, 108 gpr_w6, gpr_w7, gpr_w8, gpr_w9, 109 gpr_w10, gpr_w11, gpr_w12, gpr_w13, 110 gpr_w14, gpr_w15, gpr_w16, gpr_w17, 111 gpr_w18, gpr_w19, gpr_w20, gpr_w21, 112 gpr_w22, gpr_w23, gpr_w24, gpr_w25, 113 gpr_w26, gpr_w27, gpr_w28, LLDB_INVALID_REGNUM}; 114 115 static_assert(((sizeof g_gpr_regnums_arm64 / sizeof g_gpr_regnums_arm64[0]) - 116 1) == k_num_gpr_registers, 117 "g_gpr_regnums_arm64 has wrong number of register infos"); 118 119 // ARM64 floating point registers. 120 static const uint32_t g_fpu_regnums_arm64[] = { 121 fpu_v0, fpu_v1, fpu_v2, 122 fpu_v3, fpu_v4, fpu_v5, 123 fpu_v6, fpu_v7, fpu_v8, 124 fpu_v9, fpu_v10, fpu_v11, 125 fpu_v12, fpu_v13, fpu_v14, 126 fpu_v15, fpu_v16, fpu_v17, 127 fpu_v18, fpu_v19, fpu_v20, 128 fpu_v21, fpu_v22, fpu_v23, 129 fpu_v24, fpu_v25, fpu_v26, 130 fpu_v27, fpu_v28, fpu_v29, 131 fpu_v30, fpu_v31, fpu_s0, 132 fpu_s1, fpu_s2, fpu_s3, 133 fpu_s4, fpu_s5, fpu_s6, 134 fpu_s7, fpu_s8, fpu_s9, 135 fpu_s10, fpu_s11, fpu_s12, 136 fpu_s13, fpu_s14, fpu_s15, 137 fpu_s16, fpu_s17, fpu_s18, 138 fpu_s19, fpu_s20, fpu_s21, 139 fpu_s22, fpu_s23, fpu_s24, 140 fpu_s25, fpu_s26, fpu_s27, 141 fpu_s28, fpu_s29, fpu_s30, 142 fpu_s31, fpu_d0, fpu_d1, 143 fpu_d2, fpu_d3, fpu_d4, 144 fpu_d5, fpu_d6, fpu_d7, 145 fpu_d8, fpu_d9, fpu_d10, 146 fpu_d11, fpu_d12, fpu_d13, 147 fpu_d14, fpu_d15, fpu_d16, 148 fpu_d17, fpu_d18, fpu_d19, 149 fpu_d20, fpu_d21, fpu_d22, 150 fpu_d23, fpu_d24, fpu_d25, 151 fpu_d26, fpu_d27, fpu_d28, 152 fpu_d29, fpu_d30, fpu_d31, 153 fpu_fpsr, fpu_fpcr, LLDB_INVALID_REGNUM}; 154 static_assert(((sizeof g_fpu_regnums_arm64 / sizeof g_fpu_regnums_arm64[0]) - 155 1) == k_num_fpr_registers, 156 "g_fpu_regnums_arm64 has wrong number of register infos"); 157 158 // ARM64 SVE registers. 159 static const uint32_t g_sve_regnums_arm64[] = { 160 sve_vg, sve_z0, sve_z1, 161 sve_z2, sve_z3, sve_z4, 162 sve_z5, sve_z6, sve_z7, 163 sve_z8, sve_z9, sve_z10, 164 sve_z11, sve_z12, sve_z13, 165 sve_z14, sve_z15, sve_z16, 166 sve_z17, sve_z18, sve_z19, 167 sve_z20, sve_z21, sve_z22, 168 sve_z23, sve_z24, sve_z25, 169 sve_z26, sve_z27, sve_z28, 170 sve_z29, sve_z30, sve_z31, 171 sve_p0, sve_p1, sve_p2, 172 sve_p3, sve_p4, sve_p5, 173 sve_p6, sve_p7, sve_p8, 174 sve_p9, sve_p10, sve_p11, 175 sve_p12, sve_p13, sve_p14, 176 sve_p15, sve_ffr, LLDB_INVALID_REGNUM}; 177 static_assert(((sizeof g_sve_regnums_arm64 / sizeof g_sve_regnums_arm64[0]) - 178 1) == k_num_sve_registers, 179 "g_sve_regnums_arm64 has wrong number of register infos"); 180 181 // Register sets for ARM64. 182 static const lldb_private::RegisterSet g_reg_sets_arm64[k_num_register_sets] = { 183 {"General Purpose Registers", "gpr", k_num_gpr_registers, 184 g_gpr_regnums_arm64}, 185 {"Floating Point Registers", "fpu", k_num_fpr_registers, 186 g_fpu_regnums_arm64}, 187 {"Scalable Vector Extension Registers", "sve", k_num_sve_registers, 188 g_sve_regnums_arm64}}; 189 190 static const lldb_private::RegisterSet g_reg_set_pauth_arm64 = { 191 "Pointer Authentication Registers", "pauth", k_num_pauth_register, nullptr}; 192 193 static const lldb_private::RegisterSet g_reg_set_mte_arm64 = { 194 "MTE Control Register", "mte", k_num_mte_register, nullptr}; 195 196 static const lldb_private::RegisterSet g_reg_set_tls_arm64 = { 197 "Thread Local Storage Registers", "tls", k_num_tls_register, nullptr}; 198 199 RegisterInfoPOSIX_arm64::RegisterInfoPOSIX_arm64( 200 const lldb_private::ArchSpec &target_arch, lldb_private::Flags opt_regsets) 201 : lldb_private::RegisterInfoAndSetInterface(target_arch), 202 m_opt_regsets(opt_regsets) { 203 switch (target_arch.GetMachine()) { 204 case llvm::Triple::aarch64: 205 case llvm::Triple::aarch64_32: { 206 m_register_set_p = g_reg_sets_arm64; 207 m_register_set_count = k_num_register_sets_default; 208 m_per_regset_regnum_range[GPRegSet] = std::make_pair(gpr_x0, gpr_w28 + 1); 209 m_per_regset_regnum_range[FPRegSet] = std::make_pair(fpu_v0, fpu_fpcr + 1); 210 211 // Now configure register sets supported by current target. If we have a 212 // dynamic register set like MTE, Pointer Authentication regset then we need 213 // to create dynamic register infos and regset array. Push back all optional 214 // register infos and regset and calculate register offsets accordingly. 215 if (m_opt_regsets.AllSet(eRegsetMaskSVE)) { 216 m_register_info_p = g_register_infos_arm64_sve_le; 217 m_register_info_count = sve_ffr + 1; 218 m_per_regset_regnum_range[m_register_set_count++] = 219 std::make_pair(sve_vg, sve_ffr + 1); 220 } else { 221 m_register_info_p = g_register_infos_arm64_le; 222 m_register_info_count = fpu_fpcr + 1; 223 } 224 225 if (m_opt_regsets.AnySet(eRegsetMaskDynamic)) { 226 llvm::ArrayRef<lldb_private::RegisterInfo> reg_infos_ref = 227 llvm::ArrayRef(m_register_info_p, m_register_info_count); 228 llvm::ArrayRef<lldb_private::RegisterSet> reg_sets_ref = 229 llvm::ArrayRef(m_register_set_p, m_register_set_count); 230 llvm::copy(reg_infos_ref, std::back_inserter(m_dynamic_reg_infos)); 231 llvm::copy(reg_sets_ref, std::back_inserter(m_dynamic_reg_sets)); 232 233 if (m_opt_regsets.AllSet(eRegsetMaskPAuth)) 234 AddRegSetPAuth(); 235 236 if (m_opt_regsets.AllSet(eRegsetMaskMTE)) 237 AddRegSetMTE(); 238 239 // tpidr is always present, but in future there will be others so this is 240 // done as a dynamic set. 241 AddRegSetTLS(); 242 243 m_register_info_count = m_dynamic_reg_infos.size(); 244 m_register_info_p = m_dynamic_reg_infos.data(); 245 m_register_set_p = m_dynamic_reg_sets.data(); 246 m_register_set_count = m_dynamic_reg_sets.size(); 247 } 248 break; 249 } 250 default: 251 assert(false && "Unhandled target architecture."); 252 } 253 } 254 255 uint32_t RegisterInfoPOSIX_arm64::GetRegisterCount() const { 256 return m_register_info_count; 257 } 258 259 size_t RegisterInfoPOSIX_arm64::GetGPRSizeStatic() { 260 return sizeof(struct RegisterInfoPOSIX_arm64::GPR); 261 } 262 263 size_t RegisterInfoPOSIX_arm64::GetFPRSize() const { 264 return sizeof(struct RegisterInfoPOSIX_arm64::FPU); 265 } 266 267 const lldb_private::RegisterInfo * 268 RegisterInfoPOSIX_arm64::GetRegisterInfo() const { 269 return m_register_info_p; 270 } 271 272 size_t RegisterInfoPOSIX_arm64::GetRegisterSetCount() const { 273 return m_register_set_count; 274 } 275 276 size_t RegisterInfoPOSIX_arm64::GetRegisterSetFromRegisterIndex( 277 uint32_t reg_index) const { 278 for (const auto ®set_range : m_per_regset_regnum_range) { 279 if (reg_index >= regset_range.second.first && 280 reg_index < regset_range.second.second) 281 return regset_range.first; 282 } 283 return LLDB_INVALID_REGNUM; 284 } 285 286 const lldb_private::RegisterSet * 287 RegisterInfoPOSIX_arm64::GetRegisterSet(size_t set_index) const { 288 if (set_index < GetRegisterSetCount()) 289 return &m_register_set_p[set_index]; 290 return nullptr; 291 } 292 293 void RegisterInfoPOSIX_arm64::AddRegSetPAuth() { 294 uint32_t pa_regnum = m_dynamic_reg_infos.size(); 295 for (uint32_t i = 0; i < k_num_pauth_register; i++) { 296 pauth_regnum_collection.push_back(pa_regnum + i); 297 m_dynamic_reg_infos.push_back(g_register_infos_pauth[i]); 298 m_dynamic_reg_infos[pa_regnum + i].byte_offset = 299 m_dynamic_reg_infos[pa_regnum + i - 1].byte_offset + 300 m_dynamic_reg_infos[pa_regnum + i - 1].byte_size; 301 m_dynamic_reg_infos[pa_regnum + i].kinds[lldb::eRegisterKindLLDB] = 302 pa_regnum + i; 303 } 304 305 m_per_regset_regnum_range[m_register_set_count] = 306 std::make_pair(pa_regnum, m_dynamic_reg_infos.size()); 307 m_dynamic_reg_sets.push_back(g_reg_set_pauth_arm64); 308 m_dynamic_reg_sets.back().registers = pauth_regnum_collection.data(); 309 } 310 311 void RegisterInfoPOSIX_arm64::AddRegSetMTE() { 312 uint32_t mte_regnum = m_dynamic_reg_infos.size(); 313 m_mte_regnum_collection.push_back(mte_regnum); 314 m_dynamic_reg_infos.push_back(g_register_infos_mte[0]); 315 m_dynamic_reg_infos[mte_regnum].byte_offset = 316 m_dynamic_reg_infos[mte_regnum - 1].byte_offset + 317 m_dynamic_reg_infos[mte_regnum - 1].byte_size; 318 m_dynamic_reg_infos[mte_regnum].kinds[lldb::eRegisterKindLLDB] = mte_regnum; 319 320 m_per_regset_regnum_range[m_register_set_count] = 321 std::make_pair(mte_regnum, mte_regnum + 1); 322 m_dynamic_reg_sets.push_back(g_reg_set_mte_arm64); 323 m_dynamic_reg_sets.back().registers = m_mte_regnum_collection.data(); 324 } 325 326 void RegisterInfoPOSIX_arm64::AddRegSetTLS() { 327 uint32_t tls_regnum = m_dynamic_reg_infos.size(); 328 m_tls_regnum_collection.push_back(tls_regnum); 329 m_dynamic_reg_infos.push_back(g_register_infos_tls[0]); 330 m_dynamic_reg_infos[tls_regnum].byte_offset = 331 m_dynamic_reg_infos[tls_regnum - 1].byte_offset + 332 m_dynamic_reg_infos[tls_regnum - 1].byte_size; 333 m_dynamic_reg_infos[tls_regnum].kinds[lldb::eRegisterKindLLDB] = tls_regnum; 334 335 m_per_regset_regnum_range[m_register_set_count] = 336 std::make_pair(tls_regnum, tls_regnum + 1); 337 m_dynamic_reg_sets.push_back(g_reg_set_tls_arm64); 338 m_dynamic_reg_sets.back().registers = m_tls_regnum_collection.data(); 339 } 340 341 uint32_t RegisterInfoPOSIX_arm64::ConfigureVectorLength(uint32_t sve_vq) { 342 // sve_vq contains SVE Quad vector length in context of AArch64 SVE. 343 // SVE register infos if enabled cannot be disabled by selecting sve_vq = 0. 344 // Also if an invalid or previously set vector length is passed to this 345 // function then it will exit immediately with previously set vector length. 346 if (!VectorSizeIsValid(sve_vq) || m_vector_reg_vq == sve_vq) 347 return m_vector_reg_vq; 348 349 // We cannot enable AArch64 only mode if SVE was enabled. 350 if (sve_vq == eVectorQuadwordAArch64 && 351 m_vector_reg_vq > eVectorQuadwordAArch64) 352 sve_vq = eVectorQuadwordAArch64SVE; 353 354 m_vector_reg_vq = sve_vq; 355 356 if (sve_vq == eVectorQuadwordAArch64) 357 return m_vector_reg_vq; 358 std::vector<lldb_private::RegisterInfo> ®_info_ref = 359 m_per_vq_reg_infos[sve_vq]; 360 361 if (reg_info_ref.empty()) { 362 reg_info_ref = llvm::ArrayRef(m_register_info_p, m_register_info_count); 363 364 uint32_t offset = SVE_REGS_DEFAULT_OFFSET_LINUX; 365 reg_info_ref[fpu_fpsr].byte_offset = offset; 366 reg_info_ref[fpu_fpcr].byte_offset = offset + 4; 367 reg_info_ref[sve_vg].byte_offset = offset + 8; 368 offset += 16; 369 370 // Update Z registers size and offset 371 uint32_t s_reg_base = fpu_s0; 372 uint32_t d_reg_base = fpu_d0; 373 uint32_t v_reg_base = fpu_v0; 374 uint32_t z_reg_base = sve_z0; 375 376 for (uint32_t index = 0; index < 32; index++) { 377 reg_info_ref[s_reg_base + index].byte_offset = offset; 378 reg_info_ref[d_reg_base + index].byte_offset = offset; 379 reg_info_ref[v_reg_base + index].byte_offset = offset; 380 reg_info_ref[z_reg_base + index].byte_offset = offset; 381 382 reg_info_ref[z_reg_base + index].byte_size = sve_vq * SVE_QUAD_WORD_BYTES; 383 offset += reg_info_ref[z_reg_base + index].byte_size; 384 } 385 386 // Update P registers and FFR size and offset 387 for (uint32_t it = sve_p0; it <= sve_ffr; it++) { 388 reg_info_ref[it].byte_offset = offset; 389 reg_info_ref[it].byte_size = sve_vq * SVE_QUAD_WORD_BYTES / 8; 390 offset += reg_info_ref[it].byte_size; 391 } 392 393 for (uint32_t it = sve_ffr + 1; it < m_register_info_count; it++) { 394 reg_info_ref[it].byte_offset = offset; 395 offset += reg_info_ref[it].byte_size; 396 } 397 398 m_per_vq_reg_infos[sve_vq] = reg_info_ref; 399 } 400 401 m_register_info_p = m_per_vq_reg_infos[sve_vq].data(); 402 return m_vector_reg_vq; 403 } 404 405 bool RegisterInfoPOSIX_arm64::IsSVEReg(unsigned reg) const { 406 if (m_vector_reg_vq > eVectorQuadwordAArch64) 407 return (sve_vg <= reg && reg <= sve_ffr); 408 else 409 return false; 410 } 411 412 bool RegisterInfoPOSIX_arm64::IsSVEZReg(unsigned reg) const { 413 return (sve_z0 <= reg && reg <= sve_z31); 414 } 415 416 bool RegisterInfoPOSIX_arm64::IsSVEPReg(unsigned reg) const { 417 return (sve_p0 <= reg && reg <= sve_p15); 418 } 419 420 bool RegisterInfoPOSIX_arm64::IsSVERegVG(unsigned reg) const { 421 return sve_vg == reg; 422 } 423 424 bool RegisterInfoPOSIX_arm64::IsPAuthReg(unsigned reg) const { 425 return llvm::is_contained(pauth_regnum_collection, reg); 426 } 427 428 bool RegisterInfoPOSIX_arm64::IsMTEReg(unsigned reg) const { 429 return llvm::is_contained(m_mte_regnum_collection, reg); 430 } 431 432 bool RegisterInfoPOSIX_arm64::IsTLSReg(unsigned reg) const { 433 return llvm::is_contained(m_tls_regnum_collection, reg); 434 } 435 436 uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEZ0() const { return sve_z0; } 437 438 uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEFFR() const { return sve_ffr; } 439 440 uint32_t RegisterInfoPOSIX_arm64::GetRegNumFPCR() const { return fpu_fpcr; } 441 442 uint32_t RegisterInfoPOSIX_arm64::GetRegNumFPSR() const { return fpu_fpsr; } 443 444 uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEVG() const { return sve_vg; } 445 446 uint32_t RegisterInfoPOSIX_arm64::GetPAuthOffset() const { 447 return m_register_info_p[pauth_regnum_collection[0]].byte_offset; 448 } 449 450 uint32_t RegisterInfoPOSIX_arm64::GetMTEOffset() const { 451 return m_register_info_p[m_mte_regnum_collection[0]].byte_offset; 452 } 453 454 uint32_t RegisterInfoPOSIX_arm64::GetTLSOffset() const { 455 return m_register_info_p[m_tls_regnum_collection[0]].byte_offset; 456 } 457