1 /*
2 * ARM v8.3-PAuth Operations
3 *
4 * Copyright (c) 2019 Linaro, Ltd.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "internals.h"
23 #include "cpu-features.h"
24 #include "accel/tcg/cpu-ldst.h"
25 #include "exec/helper-proto.h"
26 #include "tcg/tcg-gvec-desc.h"
27 #include "qemu/xxhash.h"
28
29
pac_cell_shuffle(uint64_t i)30 static uint64_t pac_cell_shuffle(uint64_t i)
31 {
32 uint64_t o = 0;
33
34 o |= extract64(i, 52, 4);
35 o |= extract64(i, 24, 4) << 4;
36 o |= extract64(i, 44, 4) << 8;
37 o |= extract64(i, 0, 4) << 12;
38
39 o |= extract64(i, 28, 4) << 16;
40 o |= extract64(i, 48, 4) << 20;
41 o |= extract64(i, 4, 4) << 24;
42 o |= extract64(i, 40, 4) << 28;
43
44 o |= extract64(i, 32, 4) << 32;
45 o |= extract64(i, 12, 4) << 36;
46 o |= extract64(i, 56, 4) << 40;
47 o |= extract64(i, 20, 4) << 44;
48
49 o |= extract64(i, 8, 4) << 48;
50 o |= extract64(i, 36, 4) << 52;
51 o |= extract64(i, 16, 4) << 56;
52 o |= extract64(i, 60, 4) << 60;
53
54 return o;
55 }
56
pac_cell_inv_shuffle(uint64_t i)57 static uint64_t pac_cell_inv_shuffle(uint64_t i)
58 {
59 uint64_t o = 0;
60
61 o |= extract64(i, 12, 4);
62 o |= extract64(i, 24, 4) << 4;
63 o |= extract64(i, 48, 4) << 8;
64 o |= extract64(i, 36, 4) << 12;
65
66 o |= extract64(i, 56, 4) << 16;
67 o |= extract64(i, 44, 4) << 20;
68 o |= extract64(i, 4, 4) << 24;
69 o |= extract64(i, 16, 4) << 28;
70
71 o |= i & MAKE_64BIT_MASK(32, 4);
72 o |= extract64(i, 52, 4) << 36;
73 o |= extract64(i, 28, 4) << 40;
74 o |= extract64(i, 8, 4) << 44;
75
76 o |= extract64(i, 20, 4) << 48;
77 o |= extract64(i, 0, 4) << 52;
78 o |= extract64(i, 40, 4) << 56;
79 o |= i & MAKE_64BIT_MASK(60, 4);
80
81 return o;
82 }
83
pac_sub(uint64_t i)84 static uint64_t pac_sub(uint64_t i)
85 {
86 static const uint8_t sub[16] = {
87 0xb, 0x6, 0x8, 0xf, 0xc, 0x0, 0x9, 0xe,
88 0x3, 0x7, 0x4, 0x5, 0xd, 0x2, 0x1, 0xa,
89 };
90 uint64_t o = 0;
91 int b;
92
93 for (b = 0; b < 64; b += 4) {
94 o |= (uint64_t)sub[(i >> b) & 0xf] << b;
95 }
96 return o;
97 }
98
pac_sub1(uint64_t i)99 static uint64_t pac_sub1(uint64_t i)
100 {
101 static const uint8_t sub1[16] = {
102 0xa, 0xd, 0xe, 0x6, 0xf, 0x7, 0x3, 0x5,
103 0x9, 0x8, 0x0, 0xc, 0xb, 0x1, 0x2, 0x4,
104 };
105 uint64_t o = 0;
106 int b;
107
108 for (b = 0; b < 64; b += 4) {
109 o |= (uint64_t)sub1[(i >> b) & 0xf] << b;
110 }
111 return o;
112 }
113
pac_inv_sub(uint64_t i)114 static uint64_t pac_inv_sub(uint64_t i)
115 {
116 static const uint8_t inv_sub[16] = {
117 0x5, 0xe, 0xd, 0x8, 0xa, 0xb, 0x1, 0x9,
118 0x2, 0x6, 0xf, 0x0, 0x4, 0xc, 0x7, 0x3,
119 };
120 uint64_t o = 0;
121 int b;
122
123 for (b = 0; b < 64; b += 4) {
124 o |= (uint64_t)inv_sub[(i >> b) & 0xf] << b;
125 }
126 return o;
127 }
128
rot_cell(int cell,int n)129 static int rot_cell(int cell, int n)
130 {
131 /* 4-bit rotate left by n. */
132 cell |= cell << 4;
133 return extract32(cell, 4 - n, 4);
134 }
135
pac_mult(uint64_t i)136 static uint64_t pac_mult(uint64_t i)
137 {
138 uint64_t o = 0;
139 int b;
140
141 for (b = 0; b < 4 * 4; b += 4) {
142 int i0, i4, i8, ic, t0, t1, t2, t3;
143
144 i0 = extract64(i, b, 4);
145 i4 = extract64(i, b + 4 * 4, 4);
146 i8 = extract64(i, b + 8 * 4, 4);
147 ic = extract64(i, b + 12 * 4, 4);
148
149 t0 = rot_cell(i8, 1) ^ rot_cell(i4, 2) ^ rot_cell(i0, 1);
150 t1 = rot_cell(ic, 1) ^ rot_cell(i4, 1) ^ rot_cell(i0, 2);
151 t2 = rot_cell(ic, 2) ^ rot_cell(i8, 1) ^ rot_cell(i0, 1);
152 t3 = rot_cell(ic, 1) ^ rot_cell(i8, 2) ^ rot_cell(i4, 1);
153
154 o |= (uint64_t)t3 << b;
155 o |= (uint64_t)t2 << (b + 4 * 4);
156 o |= (uint64_t)t1 << (b + 8 * 4);
157 o |= (uint64_t)t0 << (b + 12 * 4);
158 }
159 return o;
160 }
161
tweak_cell_rot(uint64_t cell)162 static uint64_t tweak_cell_rot(uint64_t cell)
163 {
164 return (cell >> 1) | (((cell ^ (cell >> 1)) & 1) << 3);
165 }
166
tweak_shuffle(uint64_t i)167 static uint64_t tweak_shuffle(uint64_t i)
168 {
169 uint64_t o = 0;
170
171 o |= extract64(i, 16, 4) << 0;
172 o |= extract64(i, 20, 4) << 4;
173 o |= tweak_cell_rot(extract64(i, 24, 4)) << 8;
174 o |= extract64(i, 28, 4) << 12;
175
176 o |= tweak_cell_rot(extract64(i, 44, 4)) << 16;
177 o |= extract64(i, 8, 4) << 20;
178 o |= extract64(i, 12, 4) << 24;
179 o |= tweak_cell_rot(extract64(i, 32, 4)) << 28;
180
181 o |= extract64(i, 48, 4) << 32;
182 o |= extract64(i, 52, 4) << 36;
183 o |= extract64(i, 56, 4) << 40;
184 o |= tweak_cell_rot(extract64(i, 60, 4)) << 44;
185
186 o |= tweak_cell_rot(extract64(i, 0, 4)) << 48;
187 o |= extract64(i, 4, 4) << 52;
188 o |= tweak_cell_rot(extract64(i, 40, 4)) << 56;
189 o |= tweak_cell_rot(extract64(i, 36, 4)) << 60;
190
191 return o;
192 }
193
tweak_cell_inv_rot(uint64_t cell)194 static uint64_t tweak_cell_inv_rot(uint64_t cell)
195 {
196 return ((cell << 1) & 0xf) | ((cell & 1) ^ (cell >> 3));
197 }
198
tweak_inv_shuffle(uint64_t i)199 static uint64_t tweak_inv_shuffle(uint64_t i)
200 {
201 uint64_t o = 0;
202
203 o |= tweak_cell_inv_rot(extract64(i, 48, 4));
204 o |= extract64(i, 52, 4) << 4;
205 o |= extract64(i, 20, 4) << 8;
206 o |= extract64(i, 24, 4) << 12;
207
208 o |= extract64(i, 0, 4) << 16;
209 o |= extract64(i, 4, 4) << 20;
210 o |= tweak_cell_inv_rot(extract64(i, 8, 4)) << 24;
211 o |= extract64(i, 12, 4) << 28;
212
213 o |= tweak_cell_inv_rot(extract64(i, 28, 4)) << 32;
214 o |= tweak_cell_inv_rot(extract64(i, 60, 4)) << 36;
215 o |= tweak_cell_inv_rot(extract64(i, 56, 4)) << 40;
216 o |= tweak_cell_inv_rot(extract64(i, 16, 4)) << 44;
217
218 o |= extract64(i, 32, 4) << 48;
219 o |= extract64(i, 36, 4) << 52;
220 o |= extract64(i, 40, 4) << 56;
221 o |= tweak_cell_inv_rot(extract64(i, 44, 4)) << 60;
222
223 return o;
224 }
225
pauth_computepac_architected(uint64_t data,uint64_t modifier,ARMPACKey key,bool isqarma3)226 static uint64_t pauth_computepac_architected(uint64_t data, uint64_t modifier,
227 ARMPACKey key, bool isqarma3)
228 {
229 static const uint64_t RC[5] = {
230 0x0000000000000000ull,
231 0x13198A2E03707344ull,
232 0xA4093822299F31D0ull,
233 0x082EFA98EC4E6C89ull,
234 0x452821E638D01377ull,
235 };
236 const uint64_t alpha = 0xC0AC29B7C97C50DDull;
237 int iterations = isqarma3 ? 2 : 4;
238 /*
239 * Note that in the ARM pseudocode, key0 contains bits <127:64>
240 * and key1 contains bits <63:0> of the 128-bit key.
241 */
242 uint64_t key0 = key.hi, key1 = key.lo;
243 uint64_t workingval, runningmod, roundkey, modk0;
244 int i;
245
246 modk0 = (key0 << 63) | ((key0 >> 1) ^ (key0 >> 63));
247 runningmod = modifier;
248 workingval = data ^ key0;
249
250 for (i = 0; i <= iterations; ++i) {
251 roundkey = key1 ^ runningmod;
252 workingval ^= roundkey;
253 workingval ^= RC[i];
254 if (i > 0) {
255 workingval = pac_cell_shuffle(workingval);
256 workingval = pac_mult(workingval);
257 }
258 if (isqarma3) {
259 workingval = pac_sub1(workingval);
260 } else {
261 workingval = pac_sub(workingval);
262 }
263 runningmod = tweak_shuffle(runningmod);
264 }
265 roundkey = modk0 ^ runningmod;
266 workingval ^= roundkey;
267 workingval = pac_cell_shuffle(workingval);
268 workingval = pac_mult(workingval);
269 if (isqarma3) {
270 workingval = pac_sub1(workingval);
271 } else {
272 workingval = pac_sub(workingval);
273 }
274 workingval = pac_cell_shuffle(workingval);
275 workingval = pac_mult(workingval);
276 workingval ^= key1;
277 workingval = pac_cell_inv_shuffle(workingval);
278 if (isqarma3) {
279 workingval = pac_sub1(workingval);
280 } else {
281 workingval = pac_inv_sub(workingval);
282 }
283 workingval = pac_mult(workingval);
284 workingval = pac_cell_inv_shuffle(workingval);
285 workingval ^= key0;
286 workingval ^= runningmod;
287 for (i = 0; i <= iterations; ++i) {
288 if (isqarma3) {
289 workingval = pac_sub1(workingval);
290 } else {
291 workingval = pac_inv_sub(workingval);
292 }
293 if (i < iterations) {
294 workingval = pac_mult(workingval);
295 workingval = pac_cell_inv_shuffle(workingval);
296 }
297 runningmod = tweak_inv_shuffle(runningmod);
298 roundkey = key1 ^ runningmod;
299 workingval ^= RC[iterations - i];
300 workingval ^= roundkey;
301 workingval ^= alpha;
302 }
303 workingval ^= modk0;
304
305 return workingval;
306 }
307
pauth_computepac_impdef(uint64_t data,uint64_t modifier,ARMPACKey key)308 static uint64_t pauth_computepac_impdef(uint64_t data, uint64_t modifier,
309 ARMPACKey key)
310 {
311 return qemu_xxhash64_4(data, modifier, key.lo, key.hi);
312 }
313
pauth_computepac(CPUARMState * env,uint64_t data,uint64_t modifier,ARMPACKey key)314 static uint64_t pauth_computepac(CPUARMState *env, uint64_t data,
315 uint64_t modifier, ARMPACKey key)
316 {
317 if (cpu_isar_feature(aa64_pauth_qarma5, env_archcpu(env))) {
318 return pauth_computepac_architected(data, modifier, key, false);
319 } else if (cpu_isar_feature(aa64_pauth_qarma3, env_archcpu(env))) {
320 return pauth_computepac_architected(data, modifier, key, true);
321 } else {
322 return pauth_computepac_impdef(data, modifier, key);
323 }
324 }
325
pauth_addpac(CPUARMState * env,uint64_t ptr,uint64_t modifier,ARMPACKey * key,bool data)326 static uint64_t pauth_addpac(CPUARMState *env, uint64_t ptr, uint64_t modifier,
327 ARMPACKey *key, bool data)
328 {
329 ARMCPU *cpu = env_archcpu(env);
330 ARMMMUIdx mmu_idx = arm_stage1_mmu_idx(env);
331 ARMVAParameters param = aa64_va_parameters(env, ptr, mmu_idx, data, false);
332 ARMPauthFeature pauth_feature = cpu_isar_feature(pauth_feature, cpu);
333 uint64_t pac, ext_ptr, ext, test;
334 int bot_bit, top_bit;
335
336 /* If tagged pointers are in use, use ptr<55>, otherwise ptr<63>. */
337 if (param.tbi) {
338 ext = sextract64(ptr, 55, 1);
339 } else {
340 ext = sextract64(ptr, 63, 1);
341 }
342
343 /* Build a pointer with known good extension bits. */
344 top_bit = 64 - 8 * param.tbi;
345 bot_bit = 64 - param.tsz;
346 ext_ptr = deposit64(ptr, bot_bit, top_bit - bot_bit, ext);
347
348 pac = pauth_computepac(env, ext_ptr, modifier, *key);
349
350 /*
351 * Check if the ptr has good extension bits and corrupt the
352 * pointer authentication code if not.
353 */
354 test = sextract64(ptr, bot_bit, top_bit - bot_bit);
355 if (test != 0 && test != -1) {
356 if (pauth_feature >= PauthFeat_2) {
357 /* No action required */
358 } else if (pauth_feature == PauthFeat_EPAC) {
359 pac = 0;
360 } else {
361 /*
362 * Note that our top_bit is one greater than the pseudocode's
363 * version, hence "- 2" here.
364 */
365 pac ^= MAKE_64BIT_MASK(top_bit - 2, 1);
366 }
367 }
368
369 /*
370 * Preserve the determination between upper and lower at bit 55,
371 * and insert pointer authentication code.
372 */
373 if (pauth_feature >= PauthFeat_2) {
374 pac ^= ptr;
375 }
376 if (param.tbi) {
377 ptr &= ~MAKE_64BIT_MASK(bot_bit, 55 - bot_bit + 1);
378 pac &= MAKE_64BIT_MASK(bot_bit, 54 - bot_bit + 1);
379 } else {
380 ptr &= MAKE_64BIT_MASK(0, bot_bit);
381 pac &= ~(MAKE_64BIT_MASK(55, 1) | MAKE_64BIT_MASK(0, bot_bit));
382 }
383 ext &= MAKE_64BIT_MASK(55, 1);
384 return pac | ext | ptr;
385 }
386
pauth_original_ptr(uint64_t ptr,ARMVAParameters param)387 static uint64_t pauth_original_ptr(uint64_t ptr, ARMVAParameters param)
388 {
389 uint64_t mask = pauth_ptr_mask(param);
390
391 /* Note that bit 55 is used whether or not the regime has 2 ranges. */
392 if (extract64(ptr, 55, 1)) {
393 return ptr | mask;
394 } else {
395 return ptr & ~mask;
396 }
397 }
398
399 static G_NORETURN
pauth_fail_exception(CPUARMState * env,bool data,int keynumber,uintptr_t ra)400 void pauth_fail_exception(CPUARMState *env, bool data,
401 int keynumber, uintptr_t ra)
402 {
403 raise_exception_ra(env, EXCP_UDEF, syn_pacfail(data, keynumber),
404 exception_target_el(env), ra);
405 }
406
pauth_auth(CPUARMState * env,uint64_t ptr,uint64_t modifier,ARMPACKey * key,bool data,int keynumber,uintptr_t ra,bool is_combined)407 static uint64_t pauth_auth(CPUARMState *env, uint64_t ptr, uint64_t modifier,
408 ARMPACKey *key, bool data, int keynumber,
409 uintptr_t ra, bool is_combined)
410 {
411 ARMCPU *cpu = env_archcpu(env);
412 ARMMMUIdx mmu_idx = arm_stage1_mmu_idx(env);
413 ARMVAParameters param = aa64_va_parameters(env, ptr, mmu_idx, data, false);
414 ARMPauthFeature pauth_feature = cpu_isar_feature(pauth_feature, cpu);
415 int bot_bit, top_bit;
416 uint64_t pac, orig_ptr, cmp_mask;
417
418 orig_ptr = pauth_original_ptr(ptr, param);
419 pac = pauth_computepac(env, orig_ptr, modifier, *key);
420 bot_bit = 64 - param.tsz;
421 top_bit = 64 - 8 * param.tbi;
422
423 cmp_mask = MAKE_64BIT_MASK(bot_bit, top_bit - bot_bit);
424 cmp_mask &= ~MAKE_64BIT_MASK(55, 1);
425
426 if (pauth_feature >= PauthFeat_2) {
427 ARMPauthFeature fault_feature =
428 is_combined ? PauthFeat_FPACCOMBINED : PauthFeat_FPAC;
429 uint64_t result = ptr ^ (pac & cmp_mask);
430
431 if (pauth_feature >= fault_feature
432 && ((result ^ sextract64(result, 55, 1)) & cmp_mask)) {
433 pauth_fail_exception(env, data, keynumber, ra);
434 }
435 return result;
436 }
437
438 if ((pac ^ ptr) & cmp_mask) {
439 int error_code = (keynumber << 1) | (keynumber ^ 1);
440 if (param.tbi) {
441 return deposit64(orig_ptr, 53, 2, error_code);
442 } else {
443 return deposit64(orig_ptr, 61, 2, error_code);
444 }
445 }
446 return orig_ptr;
447 }
448
pauth_strip(CPUARMState * env,uint64_t ptr,bool data)449 static uint64_t pauth_strip(CPUARMState *env, uint64_t ptr, bool data)
450 {
451 ARMMMUIdx mmu_idx = arm_stage1_mmu_idx(env);
452 ARMVAParameters param = aa64_va_parameters(env, ptr, mmu_idx, data, false);
453
454 return pauth_original_ptr(ptr, param);
455 }
456
457 static G_NORETURN
pauth_trap(CPUARMState * env,int target_el,uintptr_t ra)458 void pauth_trap(CPUARMState *env, int target_el, uintptr_t ra)
459 {
460 raise_exception_ra(env, EXCP_UDEF, syn_pactrap(), target_el, ra);
461 }
462
pauth_check_trap(CPUARMState * env,int el,uintptr_t ra)463 static void pauth_check_trap(CPUARMState *env, int el, uintptr_t ra)
464 {
465 if (el < 2 && arm_is_el2_enabled(env)) {
466 uint64_t hcr = arm_hcr_el2_eff(env);
467 bool trap = !(hcr & HCR_API);
468 if (el == 0) {
469 /* Trap only applies to EL1&0 regime. */
470 trap &= (hcr & (HCR_E2H | HCR_TGE)) != (HCR_E2H | HCR_TGE);
471 }
472 /* FIXME: ARMv8.3-NV: HCR_NV trap takes precedence for ERETA[AB]. */
473 if (trap) {
474 pauth_trap(env, 2, ra);
475 }
476 }
477 if (el < 3 && arm_feature(env, ARM_FEATURE_EL3)) {
478 if (!(env->cp15.scr_el3 & SCR_API)) {
479 pauth_trap(env, 3, ra);
480 }
481 }
482 }
483
pauth_key_enabled(CPUARMState * env,int el,uint32_t bit)484 static bool pauth_key_enabled(CPUARMState *env, int el, uint32_t bit)
485 {
486 return (arm_sctlr(env, el) & bit) != 0;
487 }
488
HELPER(pacia)489 uint64_t HELPER(pacia)(CPUARMState *env, uint64_t x, uint64_t y)
490 {
491 int el = arm_current_el(env);
492 if (!pauth_key_enabled(env, el, SCTLR_EnIA)) {
493 return x;
494 }
495 pauth_check_trap(env, el, GETPC());
496 return pauth_addpac(env, x, y, &env->keys.apia, false);
497 }
498
HELPER(pacib)499 uint64_t HELPER(pacib)(CPUARMState *env, uint64_t x, uint64_t y)
500 {
501 int el = arm_current_el(env);
502 if (!pauth_key_enabled(env, el, SCTLR_EnIB)) {
503 return x;
504 }
505 pauth_check_trap(env, el, GETPC());
506 return pauth_addpac(env, x, y, &env->keys.apib, false);
507 }
508
HELPER(pacda)509 uint64_t HELPER(pacda)(CPUARMState *env, uint64_t x, uint64_t y)
510 {
511 int el = arm_current_el(env);
512 if (!pauth_key_enabled(env, el, SCTLR_EnDA)) {
513 return x;
514 }
515 pauth_check_trap(env, el, GETPC());
516 return pauth_addpac(env, x, y, &env->keys.apda, true);
517 }
518
HELPER(pacdb)519 uint64_t HELPER(pacdb)(CPUARMState *env, uint64_t x, uint64_t y)
520 {
521 int el = arm_current_el(env);
522 if (!pauth_key_enabled(env, el, SCTLR_EnDB)) {
523 return x;
524 }
525 pauth_check_trap(env, el, GETPC());
526 return pauth_addpac(env, x, y, &env->keys.apdb, true);
527 }
528
HELPER(pacga)529 uint64_t HELPER(pacga)(CPUARMState *env, uint64_t x, uint64_t y)
530 {
531 uint64_t pac;
532
533 pauth_check_trap(env, arm_current_el(env), GETPC());
534 pac = pauth_computepac(env, x, y, env->keys.apga);
535
536 return pac & 0xffffffff00000000ull;
537 }
538
pauth_autia(CPUARMState * env,uint64_t x,uint64_t y,uintptr_t ra,bool is_combined)539 static uint64_t pauth_autia(CPUARMState *env, uint64_t x, uint64_t y,
540 uintptr_t ra, bool is_combined)
541 {
542 int el = arm_current_el(env);
543 if (!pauth_key_enabled(env, el, SCTLR_EnIA)) {
544 return x;
545 }
546 pauth_check_trap(env, el, ra);
547 return pauth_auth(env, x, y, &env->keys.apia, false, 0, ra, is_combined);
548 }
549
HELPER(autia)550 uint64_t HELPER(autia)(CPUARMState *env, uint64_t x, uint64_t y)
551 {
552 return pauth_autia(env, x, y, GETPC(), false);
553 }
554
HELPER(autia_combined)555 uint64_t HELPER(autia_combined)(CPUARMState *env, uint64_t x, uint64_t y)
556 {
557 return pauth_autia(env, x, y, GETPC(), true);
558 }
559
pauth_autib(CPUARMState * env,uint64_t x,uint64_t y,uintptr_t ra,bool is_combined)560 static uint64_t pauth_autib(CPUARMState *env, uint64_t x, uint64_t y,
561 uintptr_t ra, bool is_combined)
562 {
563 int el = arm_current_el(env);
564 if (!pauth_key_enabled(env, el, SCTLR_EnIB)) {
565 return x;
566 }
567 pauth_check_trap(env, el, ra);
568 return pauth_auth(env, x, y, &env->keys.apib, false, 1, ra, is_combined);
569 }
570
HELPER(autib)571 uint64_t HELPER(autib)(CPUARMState *env, uint64_t x, uint64_t y)
572 {
573 return pauth_autib(env, x, y, GETPC(), false);
574 }
575
HELPER(autib_combined)576 uint64_t HELPER(autib_combined)(CPUARMState *env, uint64_t x, uint64_t y)
577 {
578 return pauth_autib(env, x, y, GETPC(), true);
579 }
580
pauth_autda(CPUARMState * env,uint64_t x,uint64_t y,uintptr_t ra,bool is_combined)581 static uint64_t pauth_autda(CPUARMState *env, uint64_t x, uint64_t y,
582 uintptr_t ra, bool is_combined)
583 {
584 int el = arm_current_el(env);
585 if (!pauth_key_enabled(env, el, SCTLR_EnDA)) {
586 return x;
587 }
588 pauth_check_trap(env, el, ra);
589 return pauth_auth(env, x, y, &env->keys.apda, true, 0, ra, is_combined);
590 }
591
HELPER(autda)592 uint64_t HELPER(autda)(CPUARMState *env, uint64_t x, uint64_t y)
593 {
594 return pauth_autda(env, x, y, GETPC(), false);
595 }
596
HELPER(autda_combined)597 uint64_t HELPER(autda_combined)(CPUARMState *env, uint64_t x, uint64_t y)
598 {
599 return pauth_autda(env, x, y, GETPC(), true);
600 }
601
pauth_autdb(CPUARMState * env,uint64_t x,uint64_t y,uintptr_t ra,bool is_combined)602 static uint64_t pauth_autdb(CPUARMState *env, uint64_t x, uint64_t y,
603 uintptr_t ra, bool is_combined)
604 {
605 int el = arm_current_el(env);
606 if (!pauth_key_enabled(env, el, SCTLR_EnDB)) {
607 return x;
608 }
609 pauth_check_trap(env, el, ra);
610 return pauth_auth(env, x, y, &env->keys.apdb, true, 1, ra, is_combined);
611 }
612
HELPER(autdb)613 uint64_t HELPER(autdb)(CPUARMState *env, uint64_t x, uint64_t y)
614 {
615 return pauth_autdb(env, x, y, GETPC(), false);
616 }
617
HELPER(autdb_combined)618 uint64_t HELPER(autdb_combined)(CPUARMState *env, uint64_t x, uint64_t y)
619 {
620 return pauth_autdb(env, x, y, GETPC(), true);
621 }
622
HELPER(xpaci)623 uint64_t HELPER(xpaci)(CPUARMState *env, uint64_t a)
624 {
625 return pauth_strip(env, a, false);
626 }
627
HELPER(xpacd)628 uint64_t HELPER(xpacd)(CPUARMState *env, uint64_t a)
629 {
630 return pauth_strip(env, a, true);
631 }
632