coregrind/m_syswrap/syswrap-arm64-linux.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Platform-specific syscalls stuff.    syswrap-arm64-linux.c -----*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2013-2017 OpenWorks
  11       info@open-works.net
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 #if defined(VGP_arm64_linux)
  32
  33 #include "pub_core_basics.h"
  34 #include "pub_core_vki.h"
  35 #include "pub_core_vkiscnums.h"
  36 #include "pub_core_threadstate.h"
  37 #include "pub_core_aspacemgr.h"
  38 #include "pub_core_libcbase.h"
  39 #include "pub_core_libcassert.h"
  40 #include "pub_core_libcprint.h"
  41 #include "pub_core_libcsignal.h"
  42 #include "pub_core_options.h"
  43 #include "pub_core_scheduler.h"
  44 #include "pub_core_sigframe.h"      // For VG_(sigframe_destroy)()
  45 #include "pub_core_syscall.h"
  46 #include "pub_core_syswrap.h"
  47 #include "pub_core_tooliface.h"
  48
  49 #include "priv_types_n_macros.h"
  50 #include "priv_syswrap-generic.h"   /* for decls of generic wrappers */
  51 #include "priv_syswrap-linux.h"     /* for decls of linux-ish wrappers */
  52
  53
  54 /* ---------------------------------------------------------------------
  55    clone() handling
  56    ------------------------------------------------------------------ */
  57
  58 /* Call f(arg1), but first switch stacks, using 'stack' as the new
  59    stack, and use 'retaddr' as f's return-to address.  Also, clear all
  60    the integer registers before entering f.*/
  61 __attribute__((noreturn))
  62 void ML_(call_on_new_stack_0_1) ( Addr stack,
  63                                   Addr retaddr,
  64                                   void (*f)(Word),
  65                                   Word arg1 );
  66 //    r0 = stack
  67 //    r1 = retaddr
  68 //    r2 = f
  69 //    r3 = arg1
  70 asm(
  71 ".text\n"
  72 ".globl vgModuleLocal_call_on_new_stack_0_1\n"
  73 "vgModuleLocal_call_on_new_stack_0_1:\n"
  74 "   mov    sp, x0\n\t" /* Stack pointer */
  75 "   mov    x30, x1\n\t" /* Return address (x30 is LR) */
  76 "   mov    x0, x3\n\t" /* First argument */
  77 "   mov    x9, x2\n\t" /* 'f': x9 won't be zeroed at start of f.  Oh well. */
  78 "   mov    x1, #0\n\t" /* Clear our GPRs */
  79 "   mov    x2, #0\n\t"
  80 "   mov    x3, #0\n\t"
  81 "   mov    x4, #0\n\t"
  82 "   mov    x5, #0\n\t"
  83 "   mov    x6, #0\n\t"
  84 "   mov    x7, #0\n\t"
  85 "   mov    x8, #0\n\t"
  86 /* don't zero out x9 */
  87 "   mov    x10, #0\n\t"
  88 "   mov    x11, #0\n\t"
  89 "   mov    x12, #0\n\t"
  90 "   mov    x13, #0\n\t"
  91 "   mov    x14, #0\n\t"
  92 "   mov    x15, #0\n\t"
  93 "   mov    x16, #0\n\t"
  94 "   mov    x17, #0\n\t"
  95 "   mov    x18, #0\n\t"
  96 "   mov    x19, #0\n\t"
  97 "   mov    x20, #0\n\t"
  98 "   mov    x21, #0\n\t"
  99 "   mov    x22, #0\n\t"
 100 "   mov    x23, #0\n\t"
 101 "   mov    x24, #0\n\t"
 102 "   mov    x25, #0\n\t"
 103 "   mov    x26, #0\n\t"
 104 "   mov    x27, #0\n\t"
 105 "   mov    x28, #0\n\t"
 106 "   mov    x29, sp\n\t" /* FP = SP, in the absence of better suggestions */
 107 "   br     x9\n\t"
 108 ".previous\n"
 109 );
 110
 111
 112 /*
 113         Perform a clone system call.  clone is strange because it has
 114         fork()-like return-twice semantics, so it needs special
 115         handling here.
 116
 117         Upon entry, we have:
 118
 119             Word (*fn)(void*)   in x0
 120             void*  child_stack  in x1
 121             int    flags        in x2
 122             void*  arg          in x3
 123             pid_t* child_tid    in x4
 124             pid_t* parent_tid   in x5
 125             void*  tls_ptr      in x6
 126
 127         System call requires:
 128
 129             int    $__NR_clone  in x8
 130             int    flags        in x0
 131             void*  child_stack  in x1
 132             pid_t* parent_tid   in x2
 133             void*  tls_ptr      in x3
 134             pid_t* child_tid    in x4
 135
 136         Returns a Long encoded in the linux-arm64 way, not a SysRes.
 137 */
 138 #define __NR_CLONE        VG_STRINGIFY(__NR_clone)
 139 #define __NR_EXIT         VG_STRINGIFY(__NR_exit)
 140
 141 // See priv_syswrap-linux.h for arg profile.
 142 asm(
 143 ".text\n"
 144 ".globl do_syscall_clone_arm64_linux\n"
 145 "do_syscall_clone_arm64_linux:\n"
 146         // set up child stack, temporarily preserving fn and arg
 147 "       sub    x1, x1, #16\n"       // make space on stack
 148 "       str    x3, [x1, #8]\n"      // save arg
 149 "       str    x0, [x1, #0]\n"      // save fn
 150
 151         // setup syscall
 152 "       mov    x8, #"__NR_CLONE"\n" // syscall number
 153 "       mov    x0, x2\n"            // syscall arg1: flags
 154 "       mov    x1, x1\n"            // syscall arg2: child_stack
 155 "       mov    x2, x5\n"            // syscall arg3: parent_tid
 156 "       mov    x3, x6\n"            // syscall arg4: tls_ptr
 157 "       mov    x4, x4\n"            // syscall arg5: child_tid
 158
 159 "       svc    0\n"                 // clone()
 160
 161 "       cmp    x0, #0\n"            // child if retval == 0
 162 "       bne    1f\n"
 163
 164         // CHILD - call thread function
 165 "       ldr    x1, [sp, #0]\n"      // pop fn
 166 "       ldr    x0, [sp, #8]\n"      // pop fn arg1: arg
 167 "       add    sp, sp, #16\n"
 168 "       blr    x1\n"                // call fn
 169
 170         // exit with result
 171 "       mov    x0, x0\n"            // arg1: return value from fn
 172 "       mov    x8, #"__NR_EXIT"\n"
 173
 174 "       svc    0\n"
 175
 176         // Exit returned?!
 177 "       .word 0xFFFFFFFF\n"
 178
 179 "1:\n"  // PARENT or ERROR.  x0 holds return value from the clone syscall.
 180 "       ret\n"
 181 ".previous\n"
 182 );
 183
 184 #undef __NR_CLONE
 185 #undef __NR_EXIT
 186
 187 // forward declaration
 188 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr );
 189
 190 /* ---------------------------------------------------------------------
 191    More thread stuff
 192    ------------------------------------------------------------------ */
 193
 194 // ARM64 doesn't have any architecture specific thread stuff that
 195 // needs to be cleaned up
 196 void VG_(cleanup_thread) ( ThreadArchState* arch )
 197 {
 198 }
 199
 200 //ZZ /* Assigns tlsptr to the guest TPIDRURO.
 201 //ZZ    If needed for the specific hardware, really executes
 202 //ZZ    the set_tls syscall.
 203 //ZZ */
 204 //ZZ static SysRes sys_set_tls ( ThreadId tid, Addr tlsptr )
 205 //ZZ {
 206 //ZZ    assign_guest_tls(tid, tlsptr);
 207 //ZZ #if defined(ANDROID_HARDWARE_emulator)
 208 //ZZ    /* Android emulator does not provide an hw tls register.
 209 //ZZ       So, the tls register is emulated by the kernel.
 210 //ZZ       This emulated value is set by the __NR_ARM_set_tls syscall.
 211 //ZZ       The emulated value must be read by the kernel helper function
 212 //ZZ       located at 0xffff0fe0.
 213 //ZZ
 214 //ZZ       The emulated tlsptr is located at 0xffff0ff0
 215 //ZZ       (so slightly after the kernel helper function).
 216 //ZZ       Note that applications are not supposed to read this directly.
 217 //ZZ
 218 //ZZ       For compatibility : if there is a hw tls register, the kernel
 219 //ZZ       will put at 0xffff0fe0 the instructions to read it, so
 220 //ZZ       as to have old applications calling the kernel helper
 221 //ZZ       working properly.
 222 //ZZ
 223 //ZZ       For having emulated guest TLS working correctly with
 224 //ZZ       Valgrind, it is needed to execute the syscall to set
 225 //ZZ       the emulated TLS value in addition to the assignment
 226 //ZZ       of TPIDRURO.
 227 //ZZ
 228 //ZZ       Note: the below means that if we need thread local storage
 229 //ZZ       for Valgrind host, then there will be a conflict between
 230 //ZZ       the need of the guest tls and of the host tls.
 231 //ZZ       If all the guest code would cleanly call 0xffff0fe0,
 232 //ZZ       then we might maybe intercept this. However, at least
 233 //ZZ       __libc_preinit reads directly 0xffff0ff0.
 234 //ZZ    */
 235 //ZZ    /* ??? might call the below if auxv->u.a_val & VKI_HWCAP_TLS ???
 236 //ZZ       Unclear if real hardware having tls hw register sets
 237 //ZZ       VKI_HWCAP_TLS. */
 238 //ZZ    return VG_(do_syscall1) (__NR_ARM_set_tls, tlsptr);
 239 //ZZ #else
 240 //ZZ    return VG_(mk_SysRes_Success)( 0 );
 241 //ZZ #endif
 242 //ZZ }
 243
 244 /* ---------------------------------------------------------------------
 245    PRE/POST wrappers for arm/Linux-specific syscalls
 246    ------------------------------------------------------------------ */
 247
 248 #define PRE(name)       DEFN_PRE_TEMPLATE(arm64_linux, name)
 249 #define POST(name)      DEFN_POST_TEMPLATE(arm64_linux, name)
 250
 251 /* Add prototypes for the wrappers declared here, so that gcc doesn't
 252    harass us for not having prototypes.  Really this is a kludge --
 253    the right thing to do is to make these wrappers 'static' since they
 254    aren't visible outside this file, but that requires even more macro
 255    magic. */
 256
 257 DECL_TEMPLATE(arm64_linux, sys_fadvise64);
 258 DECL_TEMPLATE(arm64_linux, sys_mmap);
 259 //ZZ DECL_TEMPLATE(arm_linux, sys_stat64);
 260 //ZZ DECL_TEMPLATE(arm_linux, sys_lstat64);
 261 //ZZ DECL_TEMPLATE(arm_linux, sys_fstatat64);
 262 //ZZ DECL_TEMPLATE(arm_linux, sys_fstat64);
 263 //ZZ DECL_TEMPLATE(arm_linux, sys_sigreturn);
 264 DECL_TEMPLATE(arm64_linux, sys_rt_sigreturn);
 265 //ZZ DECL_TEMPLATE(arm_linux, sys_sigsuspend);
 266 //ZZ DECL_TEMPLATE(arm_linux, sys_set_tls);
 267 //ZZ DECL_TEMPLATE(arm_linux, sys_cacheflush);
 268 //ZZ DECL_TEMPLATE(arm_linux, sys_ptrace);
 269
 270 //ZZ PRE(sys_mmap2)
 271 //ZZ {
 272 //ZZ    SysRes r;
 273 //ZZ
 274 //ZZ    // Exactly like old_mmap() except:
 275 //ZZ    //  - all 6 args are passed in regs, rather than in a memory-block.
 276 //ZZ    //  - the file offset is specified in pagesize units rather than bytes,
 277 //ZZ    //    so that it can be used for files bigger than 2^32 bytes.
 278 //ZZ    // pagesize or 4K-size units in offset?  For ppc32/64-linux, this is
 279 //ZZ    // 4K-sized.  Assert that the page size is 4K here for safety.
 280 //ZZ    vg_assert(VKI_PAGE_SIZE == 4096);
 281 //ZZ    PRINT("sys_mmap2 ( %#lx, %llu, %ld, %ld, %ld, %ld )",
 282 //ZZ          ARG1, (ULong)ARG2, ARG3, ARG4, ARG5, ARG6 );
 283 //ZZ    PRE_REG_READ6(long, "mmap2",
 284 //ZZ                  unsigned long, start, unsigned long, length,
 285 //ZZ                  unsigned long, prot,  unsigned long, flags,
 286 //ZZ                  unsigned long, fd,    unsigned long, offset);
 287 //ZZ
 288 //ZZ    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5,
 289 //ZZ                                        4096 * (Off64T)ARG6 );
 290 //ZZ    SET_STATUS_from_SysRes(r);
 291 //ZZ }
 292
 293 // ARM64 FIXME is this correct?
 294 PRE(sys_fadvise64)
 295 {
 296    PRINT("sys_fadvise64 ( %ld, %ld, %lu, %ld )", SARG1, SARG2, ARG3, SARG4);
 297    PRE_REG_READ4(long, "fadvise64",
 298                  int, fd, vki_loff_t, offset, vki_size_t, len, int, advice);
 299 }
 300
 301 // ARM64 FIXME is this correct?
 302 PRE(sys_mmap)
 303 {
 304    SysRes r;
 305
 306    PRINT("sys_mmap ( %#lx, %lu, %lu, %#lx, %lu, %lu )",
 307          ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
 308    PRE_REG_READ6(long, "mmap",
 309                  unsigned long, start, unsigned long, length,
 310                  unsigned long, prot,  unsigned long, flags,
 311                  unsigned long, fd,    unsigned long, offset);
 312
 313    r = ML_(generic_PRE_sys_mmap)( tid, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6 );
 314    SET_STATUS_from_SysRes(r);
 315 }
 316
 317 //ZZ
 318 //ZZ // XXX: lstat64/fstat64/stat64 are generic, but not necessarily
 319 //ZZ // applicable to every architecture -- I think only to 32-bit archs.
 320 //ZZ // We're going to need something like linux/core_os32.h for such
 321 //ZZ // things, eventually, I think.  --njn
 322 //ZZ PRE(sys_lstat64)
 323 //ZZ {
 324 //ZZ    PRINT("sys_lstat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
 325 //ZZ    PRE_REG_READ2(long, "lstat64", char *, file_name, struct stat64 *, buf);
 326 //ZZ    PRE_MEM_RASCIIZ( "lstat64(file_name)", ARG1 );
 327 //ZZ    PRE_MEM_WRITE( "lstat64(buf)", ARG2, sizeof(struct vki_stat64) );
 328 //ZZ }
 329 //ZZ
 330 //ZZ POST(sys_lstat64)
 331 //ZZ {
 332 //ZZ    vg_assert(SUCCESS);
 333 //ZZ    if (RES == 0) {
 334 //ZZ       POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 335 //ZZ    }
 336 //ZZ }
 337 //ZZ
 338 //ZZ PRE(sys_stat64)
 339 //ZZ {
 340 //ZZ    PRINT("sys_stat64 ( %#lx(%s), %#lx )",ARG1,(char*)ARG1,ARG2);
 341 //ZZ    PRE_REG_READ2(long, "stat64", char *, file_name, struct stat64 *, buf);
 342 //ZZ    PRE_MEM_RASCIIZ( "stat64(file_name)", ARG1 );
 343 //ZZ    PRE_MEM_WRITE( "stat64(buf)", ARG2, sizeof(struct vki_stat64) );
 344 //ZZ }
 345 //ZZ
 346 //ZZ POST(sys_stat64)
 347 //ZZ {
 348 //ZZ    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 349 //ZZ }
 350 //ZZ
 351 //ZZ PRE(sys_fstatat64)
 352 //ZZ {
 353 //ZZ    PRINT("sys_fstatat64 ( %ld, %#lx(%s), %#lx )",ARG1,ARG2,(char*)ARG2,ARG3);
 354 //ZZ    PRE_REG_READ3(long, "fstatat64",
 355 //ZZ                  int, dfd, char *, file_name, struct stat64 *, buf);
 356 //ZZ    PRE_MEM_RASCIIZ( "fstatat64(file_name)", ARG2 );
 357 //ZZ    PRE_MEM_WRITE( "fstatat64(buf)", ARG3, sizeof(struct vki_stat64) );
 358 //ZZ }
 359 //ZZ
 360 //ZZ POST(sys_fstatat64)
 361 //ZZ {
 362 //ZZ    POST_MEM_WRITE( ARG3, sizeof(struct vki_stat64) );
 363 //ZZ }
 364 //ZZ
 365 //ZZ PRE(sys_fstat64)
 366 //ZZ {
 367 //ZZ    PRINT("sys_fstat64 ( %ld, %#lx )",ARG1,ARG2);
 368 //ZZ    PRE_REG_READ2(long, "fstat64", unsigned long, fd, struct stat64 *, buf);
 369 //ZZ    PRE_MEM_WRITE( "fstat64(buf)", ARG2, sizeof(struct vki_stat64) );
 370 //ZZ }
 371 //ZZ
 372 //ZZ POST(sys_fstat64)
 373 //ZZ {
 374 //ZZ    POST_MEM_WRITE( ARG2, sizeof(struct vki_stat64) );
 375 //ZZ }
 376
 377 //ZZ PRE(sys_sigreturn)
 378 //ZZ {
 379 //ZZ    /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
 380 //ZZ      an explanation of what follows. */
 381 //ZZ
 382 //ZZ    PRINT("sys_sigreturn ( )");
 383 //ZZ
 384 //ZZ    vg_assert(VG_(is_valid_tid)(tid));
 385 //ZZ    vg_assert(tid >= 1 && tid < VG_N_THREADS);
 386 //ZZ    vg_assert(VG_(is_running_thread)(tid));
 387 //ZZ
 388 //ZZ    /* Restore register state from frame and remove it */
 389 //ZZ    VG_(sigframe_destroy)(tid, False);
 390 //ZZ
 391 //ZZ    /* Tell the driver not to update the guest state with the "result",
 392 //ZZ       and set a bogus result to keep it happy. */
 393 //ZZ    *flags |= SfNoWriteResult;
 394 //ZZ    SET_STATUS_Success(0);
 395 //ZZ
 396 //ZZ    /* Check to see if any signals arose as a result of this. */
 397 //ZZ    *flags |= SfPollAfter;
 398 //ZZ }
 399
 400 PRE(sys_rt_sigreturn)
 401 {
 402   /* See comments on PRE(sys_rt_sigreturn) in syswrap-amd64-linux.c for
 403       an explanation of what follows. */
 404
 405    PRINT("rt_sigreturn ( )");
 406
 407    vg_assert(VG_(is_valid_tid)(tid));
 408    vg_assert(tid >= 1 && tid < VG_N_THREADS);
 409    vg_assert(VG_(is_running_thread)(tid));
 410
 411    /* Restore register state from frame and remove it */
 412    VG_(sigframe_destroy)(tid, True);
 413
 414    /* Tell the driver not to update the guest state with the "result",
 415       and set a bogus result to keep it happy. */
 416    *flags |= SfNoWriteResult;
 417    SET_STATUS_Success(0);
 418
 419    /* Check to see if any signals arose as a result of this. */
 420    *flags |= SfPollAfter;
 421 }
 422
 423 //ZZ /* NB: clone of x86-linux version, and ppc32-linux has an almost
 424 //ZZ    identical one. */
 425 //ZZ PRE(sys_sigsuspend)
 426 //ZZ {
 427 //ZZ    /* The C library interface to sigsuspend just takes a pointer to
 428 //ZZ       a signal mask but this system call has three arguments - the first
 429 //ZZ       two don't appear to be used by the kernel and are always passed as
 430 //ZZ       zero by glibc and the third is the first word of the signal mask
 431 //ZZ       so only 32 signals are supported.
 432 //ZZ
 433 //ZZ       In fact glibc normally uses rt_sigsuspend if it is available as
 434 //ZZ       that takes a pointer to the signal mask so supports more signals.
 435 //ZZ     */
 436 //ZZ    *flags |= SfMayBlock;
 437 //ZZ    PRINT("sys_sigsuspend ( %ld, %ld, %ld )", ARG1,ARG2,ARG3 );
 438 //ZZ    PRE_REG_READ3(int, "sigsuspend",
 439 //ZZ                  int, history0, int, history1,
 440 //ZZ                  vki_old_sigset_t, mask);
 441 //ZZ }
 442 //ZZ
 443 //ZZ /* Very much ARM specific */
 444 //ZZ
 445 //ZZ PRE(sys_set_tls)
 446 //ZZ {
 447 //ZZ    PRINT("set_tls (%lx)",ARG1);
 448 //ZZ    PRE_REG_READ1(long, "set_tls", unsigned long, addr);
 449 //ZZ
 450 //ZZ    SET_STATUS_from_SysRes( sys_set_tls( tid, ARG1 ) );
 451 //ZZ }
 452 //ZZ
 453 //ZZ PRE(sys_cacheflush)
 454 //ZZ {
 455 //ZZ    PRINT("cacheflush (%lx, %#lx, %#lx)",ARG1,ARG2,ARG3);
 456 //ZZ    PRE_REG_READ3(long, "cacheflush", void*, addrlow,void*, addrhigh,int, flags);
 457 //ZZ    VG_(discard_translations)( (Addr)ARG1,
 458 //ZZ                               ((ULong)ARG2) - ((ULong)ARG1) + 1ULL/*paranoia*/,
 459 //ZZ                               "PRE(sys_cacheflush)" );
 460 //ZZ    SET_STATUS_Success(0);
 461 //ZZ }
 462 //ZZ
 463 //ZZ // ARG3 is only used for pointers into the traced process's address
 464 //ZZ // space and for offsets into the traced process's struct
 465 //ZZ // user_regs_struct. It is never a pointer into this process's memory
 466 //ZZ // space, and we should therefore not check anything it points to.
 467 //ZZ PRE(sys_ptrace)
 468 //ZZ {
 469 //ZZ    PRINT("sys_ptrace ( %ld, %ld, %#lx, %#lx )", ARG1,ARG2,ARG3,ARG4);
 470 //ZZ    PRE_REG_READ4(int, "ptrace",
 471 //ZZ                  long, request, long, pid, long, addr, long, data);
 472 //ZZ    switch (ARG1) {
 473 //ZZ    case VKI_PTRACE_PEEKTEXT:
 474 //ZZ    case VKI_PTRACE_PEEKDATA:
 475 //ZZ    case VKI_PTRACE_PEEKUSR:
 476 //ZZ       PRE_MEM_WRITE( "ptrace(peek)", ARG4,
 477 //ZZ                 sizeof (long));
 478 //ZZ       break;
 479 //ZZ    case VKI_PTRACE_GETREGS:
 480 //ZZ       PRE_MEM_WRITE( "ptrace(getregs)", ARG4,
 481 //ZZ                 sizeof (struct vki_user_regs_struct));
 482 //ZZ       break;
 483 //ZZ    case VKI_PTRACE_GETFPREGS:
 484 //ZZ       PRE_MEM_WRITE( "ptrace(getfpregs)", ARG4,
 485 //ZZ                 sizeof (struct vki_user_fp));
 486 //ZZ       break;
 487 //ZZ    case VKI_PTRACE_GETWMMXREGS:
 488 //ZZ       PRE_MEM_WRITE( "ptrace(getwmmxregs)", ARG4,
 489 //ZZ                 VKI_IWMMXT_SIZE);
 490 //ZZ       break;
 491 //ZZ    case VKI_PTRACE_GETCRUNCHREGS:
 492 //ZZ       PRE_MEM_WRITE( "ptrace(getcrunchregs)", ARG4,
 493 //ZZ                 VKI_CRUNCH_SIZE);
 494 //ZZ       break;
 495 //ZZ    case VKI_PTRACE_GETVFPREGS:
 496 //ZZ       PRE_MEM_WRITE( "ptrace(getvfpregs)", ARG4,
 497 //ZZ                      sizeof (struct vki_user_vfp) );
 498 //ZZ       break;
 499 //ZZ    case VKI_PTRACE_GETHBPREGS:
 500 //ZZ       PRE_MEM_WRITE( "ptrace(gethbpregs)", ARG4,
 501 //ZZ                      sizeof (unsigned long) );
 502 //ZZ       break;
 503 //ZZ    case VKI_PTRACE_SETREGS:
 504 //ZZ       PRE_MEM_READ( "ptrace(setregs)", ARG4,
 505 //ZZ                 sizeof (struct vki_user_regs_struct));
 506 //ZZ       break;
 507 //ZZ    case VKI_PTRACE_SETFPREGS:
 508 //ZZ       PRE_MEM_READ( "ptrace(setfpregs)", ARG4,
 509 //ZZ                 sizeof (struct vki_user_fp));
 510 //ZZ       break;
 511 //ZZ    case VKI_PTRACE_SETWMMXREGS:
 512 //ZZ       PRE_MEM_READ( "ptrace(setwmmxregs)", ARG4,
 513 //ZZ                 VKI_IWMMXT_SIZE);
 514 //ZZ       break;
 515 //ZZ    case VKI_PTRACE_SETCRUNCHREGS:
 516 //ZZ       PRE_MEM_READ( "ptrace(setcrunchregs)", ARG4,
 517 //ZZ                 VKI_CRUNCH_SIZE);
 518 //ZZ       break;
 519 //ZZ    case VKI_PTRACE_SETVFPREGS:
 520 //ZZ       PRE_MEM_READ( "ptrace(setvfpregs)", ARG4,
 521 //ZZ                      sizeof (struct vki_user_vfp));
 522 //ZZ       break;
 523 //ZZ    case VKI_PTRACE_SETHBPREGS:
 524 //ZZ       PRE_MEM_READ( "ptrace(sethbpregs)", ARG4, sizeof(unsigned long));
 525 //ZZ       break;
 526 //ZZ    case VKI_PTRACE_GET_THREAD_AREA:
 527 //ZZ       PRE_MEM_WRITE( "ptrace(get_thread_area)", ARG4, sizeof(unsigned long));
 528 //ZZ       break;
 529 //ZZ    case VKI_PTRACE_GETEVENTMSG:
 530 //ZZ       PRE_MEM_WRITE( "ptrace(geteventmsg)", ARG4, sizeof(unsigned long));
 531 //ZZ       break;
 532 //ZZ    case VKI_PTRACE_GETSIGINFO:
 533 //ZZ       PRE_MEM_WRITE( "ptrace(getsiginfo)", ARG4, sizeof(vki_siginfo_t));
 534 //ZZ       break;
 535 //ZZ    case VKI_PTRACE_SETSIGINFO:
 536 //ZZ       PRE_MEM_READ( "ptrace(setsiginfo)", ARG4, sizeof(vki_siginfo_t));
 537 //ZZ       break;
 538 //ZZ    case VKI_PTRACE_GETREGSET:
 539 //ZZ       ML_(linux_PRE_getregset)(tid, ARG3, ARG4);
 540 //ZZ       break;
 541 //ZZ    case VKI_PTRACE_SETREGSET:
 542 //ZZ       ML_(linux_PRE_setregset)(tid, ARG3, ARG4);
 543 //ZZ       break;
 544 //ZZ    default:
 545 //ZZ       break;
 546 //ZZ    }
 547 //ZZ }
 548 //ZZ
 549 //ZZ POST(sys_ptrace)
 550 //ZZ {
 551 //ZZ    switch (ARG1) {
 552 //ZZ    case VKI_PTRACE_PEEKTEXT:
 553 //ZZ    case VKI_PTRACE_PEEKDATA:
 554 //ZZ    case VKI_PTRACE_PEEKUSR:
 555 //ZZ       POST_MEM_WRITE( ARG4, sizeof (long));
 556 //ZZ       break;
 557 //ZZ    case VKI_PTRACE_GETREGS:
 558 //ZZ       POST_MEM_WRITE( ARG4, sizeof (struct vki_user_regs_struct));
 559 //ZZ       break;
 560 //ZZ    case VKI_PTRACE_GETFPREGS:
 561 //ZZ       POST_MEM_WRITE( ARG4, sizeof (struct vki_user_fp));
 562 //ZZ       break;
 563 //ZZ    case VKI_PTRACE_GETWMMXREGS:
 564 //ZZ       POST_MEM_WRITE( ARG4, VKI_IWMMXT_SIZE);
 565 //ZZ       break;
 566 //ZZ    case VKI_PTRACE_GETCRUNCHREGS:
 567 //ZZ       POST_MEM_WRITE( ARG4, VKI_CRUNCH_SIZE);
 568 //ZZ       break;
 569 //ZZ    case VKI_PTRACE_GETVFPREGS:
 570 //ZZ       POST_MEM_WRITE( ARG4, sizeof(struct vki_user_vfp));
 571 //ZZ       break;
 572 //ZZ    case VKI_PTRACE_GET_THREAD_AREA:
 573 //ZZ    case VKI_PTRACE_GETHBPREGS:
 574 //ZZ    case VKI_PTRACE_GETEVENTMSG:
 575 //ZZ       POST_MEM_WRITE( ARG4, sizeof(unsigned long));
 576 //ZZ       break;
 577 //ZZ    case VKI_PTRACE_GETSIGINFO:
 578 //ZZ       /* XXX: This is a simplification. Different parts of the
 579 //ZZ        * siginfo_t are valid depending on the type of signal.
 580 //ZZ        */
 581 //ZZ       POST_MEM_WRITE( ARG4, sizeof(vki_siginfo_t));
 582 //ZZ       break;
 583 //ZZ    case VKI_PTRACE_GETREGSET:
 584 //ZZ       ML_(linux_POST_getregset)(tid, ARG3, ARG4);
 585 //ZZ       break;
 586 //ZZ    default:
 587 //ZZ       break;
 588 //ZZ    }
 589 //ZZ }
 590 //ZZ
 591 //ZZ #undef PRE
 592 //ZZ #undef POST
 593
 594 /* ---------------------------------------------------------------------
 595    The arm64/Linux syscall table
 596    ------------------------------------------------------------------ */
 597
 598 //ZZ #if 0
 599 //ZZ #define __NR_OABI_SYSCALL_BASE 0x900000
 600 //ZZ #else
 601 //ZZ #define __NR_OABI_SYSCALL_BASE 0x0
 602 //ZZ #endif
 603
 604 #define PLAX_(sysno, name)    WRAPPER_ENTRY_X_(arm64_linux, sysno, name)
 605 #define PLAXY(sysno, name)    WRAPPER_ENTRY_XY(arm64_linux, sysno, name)
 606
 607 // This table maps from __NR_xxx syscall numbers (from
 608 // linux/include/asm-arm/unistd.h) to the appropriate PRE/POST sys_foo()
 609 // wrappers on arm64 (as per sys_call_table in linux/arch/arm/kernel/entry.S).
 610 //
 611 // For those syscalls not handled by Valgrind, the annotation indicate its
 612 // arch/OS combination, eg. */* (generic), */Linux (Linux only), ?/?
 613 // (unknown).
 614
 615 static SyscallTableEntry syscall_main_table[] = {
 616    LINXY(__NR_io_setup,          sys_io_setup),          // 0
 617    LINX_(__NR_io_destroy,        sys_io_destroy),        // 1
 618    LINX_(__NR_io_submit,         sys_io_submit),         // 2
 619    LINXY(__NR_io_cancel,         sys_io_cancel),         // 3
 620    LINXY(__NR_io_getevents,      sys_io_getevents),      // 4
 621    LINX_(__NR_setxattr,          sys_setxattr),          // 5
 622    LINX_(__NR_lsetxattr,         sys_lsetxattr),         // 6
 623    LINX_(__NR_fsetxattr,         sys_fsetxattr),         // 7
 624    LINXY(__NR_getxattr,          sys_getxattr),          // 8
 625    LINXY(__NR_lgetxattr,         sys_lgetxattr),         // 9
 626    LINXY(__NR_fgetxattr,         sys_fgetxattr),         // 10
 627    LINXY(__NR_listxattr,         sys_listxattr),         // 11
 628    LINXY(__NR_llistxattr,        sys_llistxattr),        // 12
 629    LINXY(__NR_flistxattr,        sys_flistxattr),        // 13
 630    LINX_(__NR_removexattr,       sys_removexattr),       // 14
 631    LINX_(__NR_lremovexattr,      sys_lremovexattr),      // 15
 632    LINX_(__NR_fremovexattr,      sys_fremovexattr),      // 16
 633    GENXY(__NR_getcwd,            sys_getcwd),            // 17
 634    LINXY(__NR_lookup_dcookie,    sys_lookup_dcookie),    // 18
 635    LINXY(__NR_eventfd2,          sys_eventfd2),          // 19
 636    LINXY(__NR_epoll_create1,     sys_epoll_create1),     // 20
 637    LINX_(__NR_epoll_ctl,         sys_epoll_ctl),         // 21
 638    LINXY(__NR_epoll_pwait,       sys_epoll_pwait),       // 22
 639    GENXY(__NR_dup,               sys_dup),               // 23
 640    LINXY(__NR_dup3,              sys_dup3),              // 24
 641    LINXY(__NR_fcntl,             sys_fcntl),             // 25
 642    LINXY(__NR_inotify_init1,     sys_inotify_init1),     // 26
 643    LINX_(__NR_inotify_add_watch, sys_inotify_add_watch), // 27
 644    LINX_(__NR_inotify_rm_watch,  sys_inotify_rm_watch),  // 28
 645    LINXY(__NR_ioctl,             sys_ioctl),             // 29
 646    LINX_(__NR_ioprio_set,        sys_ioprio_set),        // 30
 647    LINX_(__NR_ioprio_get,        sys_ioprio_get),        // 31
 648    GENX_(__NR_flock,             sys_flock),             // 32
 649    LINX_(__NR_mknodat,           sys_mknodat),           // 33
 650    LINX_(__NR_mkdirat,           sys_mkdirat),           // 34
 651    LINX_(__NR_unlinkat,          sys_unlinkat),          // 35
 652    LINX_(__NR_symlinkat,         sys_symlinkat),         // 36
 653    LINX_(__NR_linkat,            sys_linkat),            // 37
 654    LINX_(__NR_renameat,          sys_renameat),          // 38
 655    LINX_(__NR_umount2,           sys_umount),            // 39
 656    LINX_(__NR_mount,             sys_mount),             // 40
 657    LINX_(__NR_pivot_root,        sys_pivot_root),        // 41
 658    //   (__NR_nfsservctl,        sys_ni_syscall),        // 42
 659    GENXY(__NR_statfs,            sys_statfs),            // 43
 660    GENXY(__NR_fstatfs,           sys_fstatfs),           // 44
 661    GENX_(__NR_truncate,          sys_truncate),          // 45
 662    GENX_(__NR_ftruncate,         sys_ftruncate),         // 46
 663    LINX_(__NR_fallocate,         sys_fallocate),         // 47
 664    LINX_(__NR_faccessat,         sys_faccessat),         // 48
 665    GENX_(__NR_chdir,             sys_chdir),             // 49
 666    GENX_(__NR_fchdir,            sys_fchdir),            // 50
 667    GENX_(__NR_chroot,            sys_chroot),            // 51
 668    GENX_(__NR_fchmod,            sys_fchmod),            // 52
 669    LINX_(__NR_fchmodat,          sys_fchmodat),          // 53
 670    LINX_(__NR_fchownat,          sys_fchownat),          // 54
 671    GENX_(__NR_fchown,            sys_fchown),            // 55
 672    LINXY(__NR_openat,            sys_openat),            // 56
 673    GENXY(__NR_close,             sys_close),             // 57
 674    LINX_(__NR_vhangup,           sys_vhangup),           // 58
 675    LINXY(__NR_pipe2,             sys_pipe2),             // 59
 676    LINX_(__NR_quotactl,          sys_quotactl),          // 60
 677    GENXY(__NR_getdents64,        sys_getdents64),        // 61
 678    LINX_(__NR_lseek,             sys_lseek),             // 62
 679    GENXY(__NR_read,              sys_read),              // 63
 680    GENX_(__NR_write,             sys_write),             // 64
 681    GENXY(__NR_readv,             sys_readv),             // 65
 682    GENX_(__NR_writev,            sys_writev),            // 66
 683    GENXY(__NR_pread64,           sys_pread64),           // 67
 684    GENX_(__NR_pwrite64,          sys_pwrite64),          // 68
 685    LINXY(__NR_preadv,            sys_preadv),            // 69
 686    LINX_(__NR_pwritev,           sys_pwritev),           // 70
 687    LINXY(__NR_sendfile,          sys_sendfile),          // 71
 688    LINXY(__NR_pselect6,          sys_pselect6),          // 72
 689    LINXY(__NR_ppoll,             sys_ppoll),             // 73
 690    LINXY(__NR_signalfd4,         sys_signalfd4),         // 74
 691    LINX_(__NR_vmsplice,          sys_vmsplice),          // 75
 692    LINX_(__NR_splice,            sys_splice),            // 76
 693    LINX_(__NR_tee,               sys_tee),               // 77
 694    LINX_(__NR_readlinkat,        sys_readlinkat),        // 78
 695    LINXY(__NR_newfstatat,        sys_newfstatat),        // 79
 696    GENXY(__NR_fstat,             sys_newfstat),          // 80
 697    GENX_(__NR_sync,              sys_sync),              // 81
 698    GENX_(__NR_fsync,             sys_fsync),             // 82
 699    GENX_(__NR_fdatasync,         sys_fdatasync),         // 83
 700    LINX_(__NR_sync_file_range,   sys_sync_file_range),   // 84
 701    LINXY(__NR_timerfd_create,    sys_timerfd_create),    // 85
 702    LINXY(__NR_timerfd_settime,   sys_timerfd_settime),   // 86
 703    LINXY(__NR_timerfd_gettime,   sys_timerfd_gettime),   // 87
 704    LINX_(__NR_utimensat,         sys_utimensat),         // 88
 705    GENX_(__NR_acct,              sys_acct),              // 89
 706    LINXY(__NR_capget,            sys_capget),            // 90
 707    LINX_(__NR_capset,            sys_capset),            // 91
 708    LINX_(__NR_personality,       sys_personality),       // 92
 709    GENX_(__NR_exit,              sys_exit),              // 93
 710    LINX_(__NR_exit_group,        sys_exit_group),        // 94
 711    LINXY(__NR_waitid,            sys_waitid),            // 95
 712    LINX_(__NR_set_tid_address,   sys_set_tid_address),   // 96
 713    LINX_(__NR_unshare,           sys_unshare),           // 97
 714    LINXY(__NR_futex,             sys_futex),             // 98
 715    LINX_(__NR_set_robust_list,   sys_set_robust_list),   // 99
 716    LINXY(__NR_get_robust_list,   sys_get_robust_list),   // 100
 717    GENXY(__NR_nanosleep,         sys_nanosleep),         // 101
 718    GENXY(__NR_getitimer,         sys_getitimer),         // 102
 719    GENXY(__NR_setitimer,         sys_setitimer),         // 103
 720    GENX_(__NR_kexec_load,        sys_ni_syscall),        // 104
 721    LINX_(__NR_init_module,       sys_init_module),       // 105
 722    LINX_(__NR_delete_module,     sys_delete_module),     // 106
 723    LINXY(__NR_timer_create,      sys_timer_create),      // 107
 724    LINXY(__NR_timer_gettime,     sys_timer_gettime),     // 108
 725    LINX_(__NR_timer_getoverrun,  sys_timer_getoverrun),  // 109
 726    LINXY(__NR_timer_settime,     sys_timer_settime),     // 110
 727    LINX_(__NR_timer_delete,      sys_timer_delete),      // 111
 728    LINX_(__NR_clock_settime,     sys_clock_settime),     // 112
 729    LINXY(__NR_clock_gettime,     sys_clock_gettime),     // 113
 730    LINXY(__NR_clock_getres,      sys_clock_getres),      // 114
 731    LINXY(__NR_clock_nanosleep,   sys_clock_nanosleep),   // 115
 732    LINXY(__NR_syslog,            sys_syslog),            // 116
 733    //   (__NR_ptrace,            sys_ptrace),            // 117
 734    LINXY(__NR_sched_setparam,    sys_sched_setparam),    // 118
 735    LINX_(__NR_sched_setscheduler,sys_sched_setscheduler),// 119
 736    LINX_(__NR_sched_getscheduler,sys_sched_getscheduler),// 120
 737    LINXY(__NR_sched_getparam,    sys_sched_getparam),    // 121
 738    LINX_(__NR_sched_setaffinity, sys_sched_setaffinity), // 122
 739    LINXY(__NR_sched_getaffinity, sys_sched_getaffinity), // 123
 740    LINX_(__NR_sched_yield,       sys_sched_yield),       // 124
 741    LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 125
 742    LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 126
 743    LINXY(__NR_sched_rr_get_interval,   sys_sched_rr_get_interval),// 127
 744    //   (__NR_restart_syscall,   sys_ni_syscall),        // 128
 745    GENX_(__NR_kill,              sys_kill),              // 129
 746    LINXY(__NR_tkill,             sys_tkill),             // 130
 747    LINX_(__NR_tgkill,            sys_tgkill),            // 131
 748    GENXY(__NR_sigaltstack,       sys_sigaltstack),       // 132
 749    LINX_(__NR_rt_sigsuspend,     sys_rt_sigsuspend),     // 133
 750    LINXY(__NR_rt_sigaction,      sys_rt_sigaction),      // 134
 751    LINXY(__NR_rt_sigprocmask,    sys_rt_sigprocmask),    // 135
 752    LINXY(__NR_rt_sigpending,     sys_rt_sigpending),     // 136
 753    LINXY(__NR_rt_sigtimedwait,   sys_rt_sigtimedwait),   // 137
 754    LINXY(__NR_rt_sigqueueinfo,   sys_rt_sigqueueinfo),   // 138
 755    PLAX_(__NR_rt_sigreturn,      sys_rt_sigreturn),      // 139
 756    GENX_(__NR_setpriority,       sys_setpriority),       // 140
 757    GENX_(__NR_getpriority,       sys_getpriority),       // 141
 758    //   (__NR_reboot,            sys_ni_syscall),        // 142
 759    GENX_(__NR_setregid,          sys_setregid),          // 143
 760    GENX_(__NR_setgid,            sys_setgid),            // 144
 761    GENX_(__NR_setreuid,          sys_setreuid),          // 145
 762    GENX_(__NR_setuid,            sys_setuid),            // 146
 763    LINX_(__NR_setresuid,         sys_setresuid),         // 147
 764    LINXY(__NR_getresuid,         sys_getresuid),         // 148
 765    LINX_(__NR_setresgid,         sys_setresgid),         // 149
 766    LINXY(__NR_getresgid,         sys_getresgid),         // 150
 767    LINX_(__NR_setfsuid,          sys_setfsuid),          // 151
 768    LINX_(__NR_setfsgid,          sys_setfsgid),          // 152
 769    GENXY(__NR_times,             sys_times),             // 153
 770    GENX_(__NR_setpgid,           sys_setpgid),           // 154
 771    GENX_(__NR_getpgid,           sys_getpgid),           // 155
 772    GENX_(__NR_getsid,            sys_getsid),            // 156
 773    GENX_(__NR_setsid,            sys_setsid),            // 157
 774    GENXY(__NR_getgroups,         sys_getgroups),         // 158
 775    GENX_(__NR_setgroups,         sys_setgroups),         // 159
 776    GENXY(__NR_uname,             sys_newuname),          // 160
 777    GENX_(__NR_sethostname,       sys_sethostname),       // 161
 778    //   (__NR_setdomainname,     sys_ni_syscall),        // 162
 779    GENXY(__NR_getrlimit,         sys_old_getrlimit),     // 163
 780    GENX_(__NR_setrlimit,         sys_setrlimit),         // 164
 781    GENXY(__NR_getrusage,         sys_getrusage),         // 165
 782    GENX_(__NR_umask,             sys_umask),             // 166
 783    LINXY(__NR_prctl,             sys_prctl),             // 167
 784    LINXY(__NR_getcpu,            sys_getcpu),            // 168
 785    GENXY(__NR_gettimeofday,      sys_gettimeofday),      // 169
 786    GENX_(__NR_settimeofday,      sys_settimeofday),      // 170
 787    LINXY(__NR_adjtimex,          sys_adjtimex),          // 171
 788    GENX_(__NR_getpid,            sys_getpid),            // 172
 789    GENX_(__NR_getppid,           sys_getppid),           // 173
 790    GENX_(__NR_getuid,            sys_getuid),            // 174
 791    GENX_(__NR_geteuid,           sys_geteuid),           // 175
 792    GENX_(__NR_getgid,            sys_getgid),            // 176
 793    GENX_(__NR_getegid,           sys_getegid),           // 177
 794    LINX_(__NR_gettid,            sys_gettid),            // 178
 795    LINXY(__NR_sysinfo,           sys_sysinfo),           // 179
 796    LINXY(__NR_mq_open,           sys_mq_open),           // 180
 797    LINX_(__NR_mq_unlink,         sys_mq_unlink),         // 181
 798    LINX_(__NR_mq_timedsend,      sys_mq_timedsend),      // 182
 799    LINXY(__NR_mq_timedreceive,   sys_mq_timedreceive),   // 183
 800    LINX_(__NR_mq_notify,         sys_mq_notify),         // 184
 801    LINXY(__NR_mq_getsetattr,     sys_mq_getsetattr),     // 185
 802    LINX_(__NR_msgget,            sys_msgget),            // 186
 803    LINXY(__NR_msgctl,            sys_msgctl),            // 187
 804    LINXY(__NR_msgrcv,            sys_msgrcv),            // 188
 805    LINX_(__NR_msgsnd,            sys_msgsnd),            // 189
 806    LINX_(__NR_semget,            sys_semget),            // 190
 807    LINXY(__NR_semctl,            sys_semctl),            // 191
 808    LINX_(__NR_semtimedop,        sys_semtimedop),        // 192
 809    LINX_(__NR_semop,             sys_semop),             // 193
 810    LINX_(__NR_shmget,            sys_shmget),            // 194
 811    LINXY(__NR_shmctl,            sys_shmctl),            // 195
 812    LINXY(__NR_shmat,             sys_shmat),             // 196
 813    LINXY(__NR_shmdt,             sys_shmdt),             // 197
 814    LINXY(__NR_socket,            sys_socket),            // 198
 815    LINXY(__NR_socketpair,        sys_socketpair),        // 199
 816    LINX_(__NR_bind,              sys_bind),              // 200
 817    LINX_(__NR_listen,            sys_listen),            // 201
 818    LINXY(__NR_accept,            sys_accept),            // 202
 819    LINX_(__NR_connect,           sys_connect),           // 203
 820    LINXY(__NR_getsockname,       sys_getsockname),       // 204
 821    LINXY(__NR_getpeername,       sys_getpeername),       // 205
 822    LINX_(__NR_sendto,            sys_sendto),            // 206
 823    LINXY(__NR_recvfrom,          sys_recvfrom),          // 207
 824    LINX_(__NR_setsockopt,        sys_setsockopt),        // 208
 825    LINXY(__NR_getsockopt,        sys_getsockopt),        // 209
 826    LINX_(__NR_shutdown,          sys_shutdown),          // 210
 827    LINX_(__NR_sendmsg,           sys_sendmsg),           // 211
 828    LINXY(__NR_recvmsg,           sys_recvmsg),           // 212
 829    LINX_(__NR_readahead,         sys_readahead),         // 213
 830    GENX_(__NR_brk,               sys_brk),               // 214
 831    GENXY(__NR_munmap,            sys_munmap),            // 215
 832    GENX_(__NR_mremap,            sys_mremap),            // 216
 833    LINX_(__NR_add_key,           sys_add_key),           // 217
 834    LINX_(__NR_request_key,       sys_request_key),       // 218
 835    LINXY(__NR_keyctl,            sys_keyctl),            // 219
 836    LINX_(__NR_clone,             sys_clone),             // 220
 837    GENX_(__NR_execve,            sys_execve),            // 221
 838    PLAX_(__NR_mmap,              sys_mmap),              // 222
 839    PLAX_(__NR_fadvise64,         sys_fadvise64),         // 223
 840    //   (__NR_swapon,            sys_swapon),            // 224
 841    //   (__NR_swapoff,           sys_swapoff),           // 225
 842    GENXY(__NR_mprotect,          sys_mprotect),          // 226
 843    GENX_(__NR_msync,             sys_msync),             // 227
 844    GENX_(__NR_mlock,             sys_mlock),             // 228
 845    GENX_(__NR_munlock,           sys_munlock),           // 229
 846    GENX_(__NR_mlockall,          sys_mlockall),          // 230
 847    LINX_(__NR_munlockall,        sys_munlockall),        // 231
 848    GENXY(__NR_mincore,           sys_mincore),           // 232
 849    GENX_(__NR_madvise,           sys_madvise),           // 233
 850    //   (__NR_remap_file_pages,  sys_ni_syscall)         // 234
 851    LINX_(__NR_mbind,             sys_mbind),             // 235
 852    LINXY(__NR_get_mempolicy,     sys_get_mempolicy),     // 236
 853    LINX_(__NR_set_mempolicy,     sys_set_mempolicy),     // 237
 854    //   (__NR_migrate_pages,     sys_ni_syscall),        // 238
 855    LINXY(__NR_move_pages,        sys_move_pages),        // 239
 856    LINXY(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo), // 240
 857    LINXY(__NR_perf_event_open,   sys_perf_event_open),   // 241
 858    LINXY(__NR_accept4,           sys_accept4),           // 242
 859    LINXY(__NR_recvmmsg,          sys_recvmmsg),          // 243
 860    GENXY(__NR_wait4,             sys_wait4),             // 260
 861    LINXY(__NR_prlimit64,         sys_prlimit64),         // 261
 862    LINXY(__NR_fanotify_init,     sys_fanotify_init),     // 262
 863    LINX_(__NR_fanotify_mark,     sys_fanotify_mark),     // 263
 864    LINXY(__NR_name_to_handle_at, sys_name_to_handle_at), // 264
 865    LINXY(__NR_open_by_handle_at, sys_open_by_handle_at), // 265
 866    LINXY(__NR_clock_adjtime,     sys_clock_adjtime),     // 266
 867    LINX_(__NR_syncfs,            sys_syncfs),            // 267
 868    //   (__NR_setns,             sys_ni_syscall),        // 268
 869    LINXY(__NR_sendmmsg,          sys_sendmmsg),          // 269
 870    LINXY(__NR_process_vm_readv,  sys_process_vm_readv),  // 270
 871    LINX_(__NR_process_vm_writev, sys_process_vm_writev), // 271
 872    LINX_(__NR_kcmp,              sys_kcmp),              // 272
 873    //   (__NR_finit_module,      sys_ni_syscall),        // 273
 874    //   (__NR_sched_setattr,     sys_ni_syscall),        // 274
 875    //   (__NR_sched_getattr,     sys_ni_syscall),        // 275
 876    LINX_(__NR_renameat2,         sys_renameat2),         // 276
 877    //   (__NR_seccomp,           sys_ni_syscall),        // 277
 878    LINXY(__NR_getrandom,         sys_getrandom),         // 278
 879    LINXY(__NR_memfd_create,      sys_memfd_create),      // 279
 880    //   (__NR_bpf,               sys_ni_syscall)         // 280
 881    //   (__NR_execveat,          sys_ni_syscall),        // 281
 882    //   (__NR_userfaultfd,       sys_ni_syscall),        // 282
 883    //   (__NR_membarrier,        sys_ni_syscall),        // 283
 884    //   (__NR_mlock2,            sys_ni_syscall),        // 284
 885    //   (__NR_copy_file_range,   sys_ni_syscall),        // 285
 886    //   (__NR_preadv2,           sys_ni_syscall),        // 286
 887    //   (__NR_pwritev2,          sys_ni_syscall),        // 287
 888    //   (__NR_pkey_mprotect,     sys_ni_syscall),        // 288
 889    //   (__NR_pkey_alloc,        sys_ni_syscall),        // 289
 890    //   (__NR_pkey_free,         sys_ni_syscall),        // 290
 891 };
 892
 893
 894 //ZZ /* These are not in the main table because there indexes are not small
 895 //ZZ    integers, but rather values close to one million.  So their
 896 //ZZ    inclusion would force the main table to be huge (about 8 MB). */
 897 //ZZ
 898 //ZZ static SyscallTableEntry ste___ARM_set_tls
 899 //ZZ    = { WRAPPER_PRE_NAME(arm_linux,sys_set_tls), NULL };
 900 //ZZ
 901 //ZZ static SyscallTableEntry ste___ARM_cacheflush
 902 //ZZ    = { WRAPPER_PRE_NAME(arm_linux,sys_cacheflush), NULL };
 903
 904 SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno )
 905 {
 906    const UInt syscall_main_table_size
 907       = sizeof(syscall_main_table) / sizeof(syscall_main_table[0]);
 908
 909    /* Is it in the contiguous initial section of the table? */
 910    if (sysno < syscall_main_table_size) {
 911       SyscallTableEntry* sys = &syscall_main_table[sysno];
 912       if (sys->before == NULL)
 913          return NULL; /* no entry */
 914       else
 915          return sys;
 916    }
 917
 918 //ZZ    /* Check if it's one of the out-of-line entries. */
 919 //ZZ    switch (sysno) {
 920 //ZZ       case __NR_ARM_set_tls:    return &ste___ARM_set_tls;
 921 //ZZ       case __NR_ARM_cacheflush: return &ste___ARM_cacheflush;
 922 //ZZ       default: break;
 923 //ZZ    }
 924
 925    /* Can't find a wrapper */
 926    return NULL;
 927 }
 928
 929 #endif // defined(VGP_arm64_linux)
 930
 931 /*--------------------------------------------------------------------*/
 932 /*--- end                                    syswrap-arm64-linux.c ---*/
 933 /*--------------------------------------------------------------------*/