diff -ur valgrind-3.15.0.orig/coregrind/m_syswrap/priv_syswrap-linux.h valgrind-3.15.0/coregrind/m_syswrap/priv_syswrap-linux.h

--- valgrind-3.15.0.orig/coregrind/m_syswrap/priv_syswrap-linux.h	2020-02-28 14:02:29.841341757 +0100

+++ valgrind-3.15.0/coregrind/m_syswrap/priv_syswrap-linux.h	2020-02-28 14:55:44.622692816 +0100

@@ -388,6 +388,28 @@

 DECL_TEMPLATE(linux, sys_kcmp);

 DECL_TEMPLATE(linux, sys_copy_file_range);

+/* 64bit time_t syscalls for 32bit arches.  */

+DECL_TEMPLATE(linux, sys_clock_gettime64)

+DECL_TEMPLATE(linux, sys_clock_settime64)

+// clock_adjtime64

+DECL_TEMPLATE(linux, sys_clock_getres_time64)

+DECL_TEMPLATE(linux, sys_clock_nanosleep_time64);

+DECL_TEMPLATE(linux, sys_timer_gettime64);

+DECL_TEMPLATE(linux, sys_timer_settime64);

+DECL_TEMPLATE(linux, sys_timerfd_gettime64);

+DECL_TEMPLATE(linux, sys_timerfd_settime64);

+DECL_TEMPLATE(linux, sys_utimensat_time64);

+DECL_TEMPLATE(linux, sys_pselect6_time64);

+DECL_TEMPLATE(linux, sys_ppoll_time64);

+// io_pgetevents_time64

+DECL_TEMPLATE(linux, sys_recvmmsg_time64);

+DECL_TEMPLATE(linux, sys_mq_timedsend_time64);

+DECL_TEMPLATE(linux, sys_mq_timedreceive_time64);

+DECL_TEMPLATE(linux, sys_semtimedop_time64);

+DECL_TEMPLATE(linux, sys_rt_sigtimedwait_time64);

+DECL_TEMPLATE(linux, sys_futex_time64);

+DECL_TEMPLATE(linux, sys_sched_rr_get_interval_time64);

+

 // Some arch specific functions called from syswrap-linux.c

 extern Int do_syscall_clone_x86_linux ( Word (*fn)(void *), 

                                         void* stack, 

diff -ur valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-arm-linux.c valgrind-3.15.0/coregrind/m_syswrap/syswrap-arm-linux.c

--- valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-arm-linux.c	2020-02-28 14:02:29.848341656 +0100

+++ valgrind-3.15.0/coregrind/m_syswrap/syswrap-arm-linux.c	2020-02-28 14:55:44.623692804 +0100

@@ -744,7 +744,7 @@

    LINX_(__NR_sched_get_priority_max, sys_sched_get_priority_max),// 159

    LINX_(__NR_sched_get_priority_min, sys_sched_get_priority_min),// 160

-//zz    //LINX?(__NR_sched_rr_get_interval,  sys_sched_rr_get_interval), // 161 */*

+   LINXY(__NR_sched_rr_get_interval,  sys_sched_rr_get_interval), // 161

    GENXY(__NR_nanosleep,         sys_nanosleep),      // 162

    GENX_(__NR_mremap,            sys_mremap),         // 163

    LINX_(__NR_setresuid,         sys_setresuid16),    // 164

@@ -1020,6 +1020,28 @@

    LINX_(__NR_copy_file_range,   sys_copy_file_range),  // 391

    LINXY(__NR_statx,             sys_statx),            // 397

+

+   LINXY(__NR_clock_gettime64,   sys_clock_gettime64),  // 403

+   LINX_(__NR_clock_settime64,   sys_clock_settime64),  // 404

+

+   LINXY(__NR_clock_getres_time64, sys_clock_getres_time64), // 406

+   LINXY(__NR_clock_nanosleep_time64, sys_clock_nanosleep_time64), // 407

+   LINXY(__NR_timer_gettime64,   sys_timer_gettime64),  // 408

+   LINXY(__NR_timer_settime64,   sys_timer_settime64),  // 409

+   LINXY(__NR_timerfd_gettime64, sys_timerfd_gettime64),// 410

+   LINXY(__NR_timerfd_settime64, sys_timerfd_settime64),// 411

+   LINX_(__NR_utimensat_time64,  sys_utimensat_time64), // 412

+   LINXY(__NR_pselect6_time64,   sys_pselect6_time64),  // 413

+   LINXY(__NR_ppoll_time64,      sys_ppoll_time64),     // 414

+

+   LINXY(__NR_recvmmsg_time64,   sys_recvmmsg_time64),  // 417

+   LINX_(__NR_mq_timedsend_time64, sys_mq_timedsend_time64), // 418

+   LINXY(__NR_mq_timedreceive_time64, sys_mq_timedreceive_time64), // 419

+   LINX_(__NR_semtimedop_time64, sys_semtimedop_time64),// 420

+   LINXY(__NR_rt_sigtimedwait_time64, sys_rt_sigtimedwait_time64), // 421

+   LINXY(__NR_futex_time64,      sys_futex_time64),     // 422

+   LINXY(__NR_sched_rr_get_interval_time64,

+         sys_sched_rr_get_interval_time64),             // 423

 };

diff -ur valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-linux.c valgrind-3.15.0/coregrind/m_syswrap/syswrap-linux.c

--- valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-linux.c	2020-02-28 14:02:29.843341728 +0100

+++ valgrind-3.15.0/coregrind/m_syswrap/syswrap-linux.c	2020-02-28 14:55:44.625692781 +0100

@@ -1584,7 +1584,9 @@

    }

 }

-PRE(sys_futex)

+static void futex_pre_helper ( ThreadId tid, SyscallArgLayout* layout,

+                               SyscallArgs* arrghs, SyscallStatus* status,

+                               UWord* flags, Bool is_time64 )

 {

    /* 

       arg    param                              used by ops

@@ -1596,21 +1598,32 @@

       ARG5 - u32 *uaddr2			REQUEUE,CMP_REQUEUE

       ARG6 - int val3				CMP_REQUEUE

     */

-   PRINT("sys_futex ( %#" FMT_REGWORD "x, %ld, %ld, %#" FMT_REGWORD

-         "x, %#" FMT_REGWORD "x )", ARG1, SARG2, SARG3, ARG4, ARG5);

+

    switch(ARG2 & ~(VKI_FUTEX_PRIVATE_FLAG|VKI_FUTEX_CLOCK_REALTIME)) {

    case VKI_FUTEX_CMP_REQUEUE:

    case VKI_FUTEX_WAKE_OP:

    case VKI_FUTEX_CMP_REQUEUE_PI:

-      PRE_REG_READ6(long, "futex", 

-                    vki_u32 *, futex, int, op, int, val,

-                    struct timespec *, utime, vki_u32 *, uaddr2, int, val3);

+      if (is_time64) {

+         PRE_REG_READ6(long, "futex_time64", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec64 *, utime, vki_u32 *, uaddr2, int, val3);

+      } else {

+         PRE_REG_READ6(long, "futex", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec *, utime, vki_u32 *, uaddr2, int, val3);

+      }

       break;

    case VKI_FUTEX_REQUEUE:

    case VKI_FUTEX_WAIT_REQUEUE_PI:

-      PRE_REG_READ5(long, "futex", 

-                    vki_u32 *, futex, int, op, int, val,

-                    struct timespec *, utime, vki_u32 *, uaddr2);

+      if (is_time64) {

+         PRE_REG_READ5(long, "futex_time64", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec64 *, utime, vki_u32 *, uaddr2);

+      } else {

+         PRE_REG_READ5(long, "futex", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec *, utime, vki_u32 *, uaddr2);

+      }

       break;

    case VKI_FUTEX_WAIT_BITSET:

       /* Check that the address at least begins in client-accessible area. */

@@ -1619,15 +1632,27 @@

             return;

       }

       if (*(vki_u32 *)(Addr)ARG1 != ARG3) {

-         PRE_REG_READ4(long, "futex",

-                       vki_u32 *, futex, int, op, int, val,

-                       struct timespec *, utime);

+         if (is_time64) {

+            PRE_REG_READ4(long, "futex_time64",

+                          vki_u32 *, futex, int, op, int, val,

+                          struct timespec64 *, utime);

+         } else {

+            PRE_REG_READ4(long, "futex",

+                          vki_u32 *, futex, int, op, int, val,

+                          struct timespec64 *, utime);

+         }

       } else {

         /* Note argument 5 is unused, but argument 6 is used.

            So we cannot just PRE_REG_READ6. Read argument 6 separately.  */

-         PRE_REG_READ4(long, "futex",

-                       vki_u32 *, futex, int, op, int, val,

-                       struct timespec *, utime);

+         if (is_time64) {

+            PRE_REG_READ4(long, "futex_time64",

+                          vki_u32 *, futex, int, op, int, val,

+                          struct timespec64 *, utime);

+         } else {

+            PRE_REG_READ4(long, "futex",

+                          vki_u32 *, futex, int, op, int, val,

+                          struct timespec *, utime);

+         }

          if (VG_(tdict).track_pre_reg_read)

             PRA6("futex",int,val3);

       }

@@ -1641,9 +1666,15 @@

       break;

    case VKI_FUTEX_WAIT:

    case VKI_FUTEX_LOCK_PI:

-      PRE_REG_READ4(long, "futex", 

-                    vki_u32 *, futex, int, op, int, val,

-                    struct timespec *, utime);

+      if (is_time64) {

+         PRE_REG_READ4(long, "futex_time64", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec64 *, utime);

+      } else {

+         PRE_REG_READ4(long, "futex", 

+                       vki_u32 *, futex, int, op, int, val,

+                       struct timespec *, utime);

+      }

       break;

    case VKI_FUTEX_WAKE:

    case VKI_FUTEX_FD:

@@ -1665,8 +1696,15 @@

    case VKI_FUTEX_WAIT_BITSET:

    case VKI_FUTEX_WAIT_REQUEUE_PI:

       PRE_MEM_READ( "futex(futex)", ARG1, sizeof(Int) );

-      if (ARG4 != 0)

-	 PRE_MEM_READ( "futex(timeout)", ARG4, sizeof(struct vki_timespec) );

+      if (ARG4 != 0) {

+         if (is_time64) {

+	    PRE_MEM_READ( "futex_time64(timeout)", ARG4,

+                          sizeof(struct vki_timespec64) );

+         } else {

+	    PRE_MEM_READ( "futex(timeout)", ARG4,

+                          sizeof(struct vki_timespec) );

+         }

+      }

       break;

    case VKI_FUTEX_REQUEUE:

@@ -1690,7 +1728,9 @@

       break;

    }

 }

-POST(sys_futex)

+

+static void futex_post_helper ( ThreadId tid, SyscallArgs* arrghs,

+                                SyscallStatus* status )

 {

    vg_assert(SUCCESS);

    POST_MEM_WRITE( ARG1, sizeof(int) );

@@ -1705,6 +1745,30 @@

    }

 }

+PRE(sys_futex)

+{

+   PRINT("sys_futex ( %#" FMT_REGWORD "x, %ld, %ld, %#" FMT_REGWORD

+         "x, %#" FMT_REGWORD "x )", ARG1, SARG2, SARG3, ARG4, ARG5);

+   futex_pre_helper (tid, layout, arrghs, status, flags, False);

+}

+

+POST(sys_futex)

+{

+  futex_post_helper (tid, arrghs, status);

+}

+

+PRE(sys_futex_time64)

+{

+   PRINT("sys_futex_time64 ( %#" FMT_REGWORD "x, %ld, %ld, %#" FMT_REGWORD

+         "x, %#" FMT_REGWORD "x )", ARG1, SARG2, SARG3, ARG4, ARG5);

+   futex_pre_helper (tid, layout, arrghs, status, flags, True);

+}

+

+POST(sys_futex_time64)

+{

+  futex_post_helper (tid, arrghs, status);

+}

+

 PRE(sys_set_robust_list)

 {

    PRINT("sys_set_robust_list ( %#" FMT_REGWORD "x, %"

@@ -1747,16 +1811,22 @@

     vki_sigset_t adjusted_ss;

 };

-PRE(sys_pselect6)

+static void pselect6_pre_helper ( ThreadId tid, SyscallArgLayout* layout,

+                                  SyscallArgs* arrghs, SyscallStatus* status,

+                                  UWord* flags, Bool is_time64 )

 {

    *flags |= SfMayBlock | SfPostOnFail;

-   PRINT("sys_pselect6 ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"

-         FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",

-         SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);

-   PRE_REG_READ6(long, "pselect6",

-                 int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,

-                 vki_fd_set *, exceptfds, struct vki_timeval *, timeout,

-                 void *, sig);

+   if (is_time64) {

+      PRE_REG_READ6(long, "pselect6_time64",

+                    int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,

+                    vki_fd_set *, exceptfds, struct vki_timespec64 *, timeout,

+                    void *, sig);

+   } else {

+      PRE_REG_READ6(long, "pselect6",

+                    int, n, vki_fd_set *, readfds, vki_fd_set *, writefds,

+                    vki_fd_set *, exceptfds, struct vki_timespec *, timeout,

+                    void *, sig);

+   }

    // XXX: this possibly understates how much memory is read.

    if (ARG2 != 0)

       PRE_MEM_READ( "pselect6(readfds)",   

@@ -1767,8 +1837,15 @@

    if (ARG4 != 0)

       PRE_MEM_READ( "pselect6(exceptfds)", 

 		     ARG4, ARG1/8 /* __FD_SETSIZE/8 */ );

-   if (ARG5 != 0)

-      PRE_MEM_READ( "pselect6(timeout)", ARG5, sizeof(struct vki_timeval) );

+   if (ARG5 != 0) {

+      if (is_time64) {

+         PRE_MEM_READ( "pselect6_time64(timeout)", ARG5,

+                       sizeof(struct vki_timespec64) );

+      } else {

+         PRE_MEM_READ( "pselect6(timeout)", ARG5,

+                       sizeof(struct vki_timespec) );

+      }

+   }

    if (ARG6 != 0) {

       const struct pselect_sized_sigset *pss =

           (struct pselect_sized_sigset *)(Addr)ARG6;

@@ -1796,6 +1873,15 @@

       }

    }

 }

+

+PRE(sys_pselect6)

+{

+   PRINT("sys_pselect6 ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"

+         FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",

+         SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);

+   pselect6_pre_helper (tid, layout, arrghs, status, flags, False);

+}

+

 POST(sys_pselect6)

 {

    if (ARG6 != 0 && ARG6 != 1) {

@@ -1803,7 +1889,24 @@

    }

 }

-PRE(sys_ppoll)

+PRE(sys_pselect6_time64)

+{

+   PRINT("sys_pselect6_time64 ( %ld, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %#"

+         FMT_REGWORD "x, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",

+         SARG1, ARG2, ARG3, ARG4, ARG5, ARG6);

+   pselect6_pre_helper (tid, layout, arrghs, status, flags, True);

+}

+

+POST(sys_pselect6_time64)

+{

+   if (ARG6 != 0 && ARG6 != 1) {

+       VG_(free)((struct pselect_adjusted_sigset *)(Addr)ARG6);

+   }

+}

+

+static void ppoll_pre_helper ( ThreadId tid, SyscallArgLayout* layout,

+                               SyscallArgs* arrghs, SyscallStatus* status,

+                               UWord* flags, Bool is_time64 )

 {

    UInt i;

    struct vki_pollfd* ufds = (struct vki_pollfd *)(Addr)ARG1;

@@ -1811,10 +1914,17 @@

    PRINT("sys_ppoll ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD

          "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )\n",

          ARG1, ARG2, ARG3, ARG4, ARG5);

-   PRE_REG_READ5(long, "ppoll",

-                 struct vki_pollfd *, ufds, unsigned int, nfds,

-                 struct vki_timespec *, tsp, vki_sigset_t *, sigmask,

-                 vki_size_t, sigsetsize);

+   if (is_time64) {

+      PRE_REG_READ5(long, "ppoll_time64",

+                    struct vki_pollfd *, ufds, unsigned int, nfds,

+                    struct vki_timespec64 *, tsp, vki_sigset_t *, sigmask,

+                    vki_size_t, sigsetsize);

+   } else {

+      PRE_REG_READ5(long, "ppoll",

+                    struct vki_pollfd *, ufds, unsigned int, nfds,

+                    struct vki_timespec *, tsp, vki_sigset_t *, sigmask,

+                    vki_size_t, sigsetsize);

+   }

    for (i = 0; i < ARG2; i++) {

       PRE_MEM_READ( "ppoll(ufds.fd)",

@@ -1825,8 +1935,15 @@

                      (Addr)(&ufds[i].revents), sizeof(ufds[i].revents) );

    }

-   if (ARG3)

-      PRE_MEM_READ( "ppoll(tsp)", ARG3, sizeof(struct vki_timespec) );

+   if (ARG3) {

+      if (is_time64) {

+         PRE_MEM_READ( "ppoll_time64(tsp)", ARG3,

+                       sizeof(struct vki_timespec64) );

+      } else {

+         PRE_MEM_READ( "ppoll(tsp)", ARG3,

+                       sizeof(struct vki_timespec) );

+      }

+   }

    if (ARG4 != 0 && sizeof(vki_sigset_t) == ARG5) {

       const vki_sigset_t *guest_sigmask = (vki_sigset_t *)(Addr)ARG4;

       PRE_MEM_READ( "ppoll(sigmask)", ARG4, ARG5);

@@ -1842,7 +1959,8 @@

    }

 }

-POST(sys_ppoll)

+static void ppoll_post_helper ( ThreadId tid, SyscallArgs* arrghs,

+                                SyscallStatus* status )

 {

    vg_assert(SUCCESS || FAILURE);

    if (SUCCESS && (RES >= 0)) {

@@ -1856,6 +1974,32 @@

    }

 }

+PRE(sys_ppoll)

+{

+   PRINT("sys_ppoll ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %#" FMT_REGWORD

+         "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )\n",

+         ARG1, ARG2, ARG3, ARG4, ARG5);

+   ppoll_pre_helper (tid, layout, arrghs, status, flags, False);

+}

+

+POST(sys_ppoll)

+{

+   ppoll_post_helper (tid, arrghs, status);

+}

+

+PRE(sys_ppoll_time64)

+{

+   PRINT("sys_ppoll_time64 ( %#" FMT_REGWORD "x, %" FMT_REGWORD

+         "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )\n",

+         ARG1, ARG2, ARG3, ARG4, ARG5);

+   ppoll_pre_helper (tid, layout, arrghs, status, flags, False);

+}

+

+POST(sys_ppoll_time64)

+{

+   ppoll_post_helper (tid, arrghs, status);

+}

+

 /* ---------------------------------------------------------------------

    epoll_* wrappers

@@ -2644,6 +2788,26 @@

    }

 }

+PRE(sys_mq_timedsend_time64)

+{

+   *flags |= SfMayBlock;

+   PRINT("sys_mq_timedsend_time64 ( %ld, %#" FMT_REGWORD "x, %" FMT_REGWORD

+         "u, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",

+         SARG1,ARG2,ARG3,ARG4,ARG5);

+   PRE_REG_READ5(long, "mq_timedsend_time64",

+                 vki_mqd_t, mqdes, const char *, msg_ptr, vki_size_t, msg_len,

+                 unsigned int, msg_prio,

+                 const struct vki_timespec64 *, abs_timeout);

+   if (!ML_(fd_allowed)(ARG1, "mq_timedsend_time64", tid, False)) {

+      SET_STATUS_Failure( VKI_EBADF );

+   } else {

+      PRE_MEM_READ( "mq_timedsend_time64(msg_ptr)", ARG2, ARG3 );

+      if (ARG5 != 0)

+         PRE_MEM_READ( "mq_timedsend_time64(abs_timeout)", ARG5,

+                        sizeof(struct vki_timespec64) );

+   }

+}

+

 PRE(sys_mq_timedreceive)

 {

    *flags |= SfMayBlock;

@@ -2673,6 +2837,36 @@

       POST_MEM_WRITE( ARG4, sizeof(unsigned int) );

 }

+PRE(sys_mq_timedreceive_time64)

+{

+   *flags |= SfMayBlock;

+   PRINT("sys_mq_timedreceive_time64( %ld, %#" FMT_REGWORD "x, %"

+         FMT_REGWORD "u, %#" FMT_REGWORD "x, %#" FMT_REGWORD "x )",

+         SARG1,ARG2,ARG3,ARG4,ARG5);

+   PRE_REG_READ5(ssize_t, "mq_timedreceive_time64",

+                 vki_mqd_t, mqdes, char *, msg_ptr, vki_size_t, msg_len,

+                 unsigned int *, msg_prio,

+                 const struct vki_timespec64 *, abs_timeout);

+   if (!ML_(fd_allowed)(ARG1, "mq_timedreceive_time64", tid, False)) {

+      SET_STATUS_Failure( VKI_EBADF );

+   } else {

+      PRE_MEM_WRITE( "mq_timedreceive_time64(msg_ptr)", ARG2, ARG3 );

+      if (ARG4 != 0)

+         PRE_MEM_WRITE( "mq_timedreceive_time64(msg_prio)",

+                        ARG4, sizeof(unsigned int) );

+      if (ARG5 != 0)

+         PRE_MEM_READ( "mq_timedreceive_time64(abs_timeout)",

+                        ARG5, sizeof(struct vki_timespec64) );

+   }

+}

+

+POST(sys_mq_timedreceive_time64)

+{

+   POST_MEM_WRITE( ARG2, RES );

+   if (ARG4 != 0)

+      POST_MEM_WRITE( ARG4, sizeof(unsigned int) );

+}

+

 PRE(sys_mq_notify)

 {

    PRINT("sys_mq_notify( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2 );

@@ -2723,6 +2917,14 @@

    PRE_MEM_READ( "clock_settime(tp)", ARG2, sizeof(struct vki_timespec) );

 }

+PRE(sys_clock_settime64)

+{

+   PRINT("sys_clock_settime64( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);

+   PRE_REG_READ2(long, "clock_settime64",

+                 vki_clockid_t, clk_id, const struct timespec64 *, tp);

+   PRE_MEM_READ( "clock_settime64(tp)", ARG2, sizeof(struct vki_timespec64) );

+}

+

 PRE(sys_clock_gettime)

 {

    PRINT("sys_clock_gettime( %ld, %#" FMT_REGWORD "x )" , SARG1, ARG2);

@@ -2735,6 +2937,18 @@

    POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );

 }

+PRE(sys_clock_gettime64)

+{

+   PRINT("sys_clock_gettime64( %ld, %#" FMT_REGWORD "x )" , SARG1, ARG2);

+   PRE_REG_READ2(long, "clock_gettime64",

+                 vki_clockid_t, clk_id, struct vki_timespec64 *, tp);

+   PRE_MEM_WRITE( "clock_gettime64(tp)", ARG2, sizeof(struct vki_timespec64) );

+}

+POST(sys_clock_gettime64)

+{

+   POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec64) );

+}

+

 PRE(sys_clock_getres)

 {

    PRINT("sys_clock_getres( %ld, %#" FMT_REGWORD "x )" , SARG1, ARG2);

@@ -2751,6 +2965,23 @@

       POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec) );

 }

+PRE(sys_clock_getres_time64)

+{

+   PRINT("sys_clock_getres_time64( %ld, %#" FMT_REGWORD "x )" , SARG1, ARG2);

+   // Nb: we can't use "RES" as the param name because that's a macro

+   // defined above!

+   PRE_REG_READ2(long, "clock_getres_time64",

+                 vki_clockid_t, clk_id, struct vki_timespec64 *, res);

+   if (ARG2 != 0)

+      PRE_MEM_WRITE( "clock_getres_time64(res)", ARG2,

+		     sizeof(struct vki_timespec64) );

+}

+POST(sys_clock_getres_time64)

+{

+   if (ARG2 != 0)

+      POST_MEM_WRITE( ARG2, sizeof(struct vki_timespec64) );

+}

+

 PRE(sys_clock_nanosleep)

 {

    *flags |= SfMayBlock|SfPostOnFail;

@@ -2770,6 +3001,28 @@

       POST_MEM_WRITE( ARG4, sizeof(struct vki_timespec) );

 }

+PRE(sys_clock_nanosleep_time64)

+{

+   *flags |= SfMayBlock|SfPostOnFail;

+   PRINT("sys_clock_nanosleep_time64( %ld, %ld, %#" FMT_REGWORD "x, %#"

+         FMT_REGWORD "x )",

+         SARG1, SARG2, ARG3, ARG4);

+   PRE_REG_READ4(int32_t, "clock_nanosleep_time64",

+                 vki_clockid_t, clkid, int, flags,

+                 const struct vki_timespec64 *, rqtp,

+		 struct vki_timespec64 *, rmtp);

+   PRE_MEM_READ( "clock_nanosleep_time64(rqtp)", ARG3,

+		 sizeof(struct vki_timespec64) );

+   if (ARG4 != 0)

+      PRE_MEM_WRITE( "clock_nanosleep_time64(rmtp)", ARG4,

+		     sizeof(struct vki_timespec64) );

+}

+POST(sys_clock_nanosleep_time64)

+{

+   if (ARG4 != 0 && FAILURE && ERR == VKI_EINTR)

+      POST_MEM_WRITE( ARG4, sizeof(struct vki_timespec64) );

+}

+

 /* ---------------------------------------------------------------------

    timer_* wrappers

    ------------------------------------------------------------------ */

@@ -2821,6 +3074,26 @@

       POST_MEM_WRITE( ARG4, sizeof(struct vki_itimerspec) );

 }

+PRE(sys_timer_settime64)

+{

+   PRINT("sys_timer_settime64( %ld, %ld, %#" FMT_REGWORD "x, %#"

+          FMT_REGWORD "x )", SARG1,SARG2,ARG3,ARG4);

+   PRE_REG_READ4(long, "timer_settime64", 

+                 vki_timer_t, timerid, int, flags,

+                 const struct vki_itimerspec64 *, value,

+                 struct vki_itimerspec64 *, ovalue);

+   PRE_MEM_READ( "timer_settime64(value)", ARG3,

+                  sizeof(struct vki_itimerspec64) );

+   if (ARG4 != 0)

+       PRE_MEM_WRITE( "timer_settime64(ovalue)", ARG4,

+                      sizeof(struct vki_itimerspec64) );

+}

+POST(sys_timer_settime64)

+{

+   if (ARG4 != 0)

+      POST_MEM_WRITE( ARG4, sizeof(struct vki_itimerspec64) );

+}

+

 PRE(sys_timer_gettime)

 {

    PRINT("sys_timer_gettime( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);

@@ -2834,6 +3107,19 @@

    POST_MEM_WRITE( ARG2, sizeof(struct vki_itimerspec) );

 }

+PRE(sys_timer_gettime64)

+{

+   PRINT("sys_timer_gettime64( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);

+   PRE_REG_READ2(long, "timer_gettime64", 

+                 vki_timer_t, timerid, struct vki_itimerspec64 *, value);

+   PRE_MEM_WRITE( "timer_gettime64(value)", ARG2,

+                  sizeof(struct vki_itimerspec64));

+}

+POST(sys_timer_gettime64)

+{

+   POST_MEM_WRITE( ARG2, sizeof(struct vki_itimerspec64) );

+}

+

 PRE(sys_timer_getoverrun)

 {

    PRINT("sys_timer_getoverrun( %#" FMT_REGWORD "x )", ARG1);

@@ -2940,6 +3226,24 @@

       POST_MEM_WRITE(ARG2, sizeof(struct vki_itimerspec));

 }

+PRE(sys_timerfd_gettime64)

+{

+   PRINT("sys_timerfd_gettime64 ( %ld, %#" FMT_REGWORD "x )", SARG1, ARG2);

+   PRE_REG_READ2(long, "timerfd_gettime64",

+                 int, ufd,

+                 struct vki_itimerspec64*, otmr);

+   if (!ML_(fd_allowed)(ARG1, "timerfd_gettime64", tid, False))

+      SET_STATUS_Failure(VKI_EBADF);

+   else

+      PRE_MEM_WRITE("timerfd_gettime64(result)",

+                    ARG2, sizeof(struct vki_itimerspec64));

+}

+POST(sys_timerfd_gettime64)

+{

+   if (RES == 0)

+      POST_MEM_WRITE(ARG2, sizeof(struct vki_itimerspec64));

+}

+

 PRE(sys_timerfd_settime)

 {

    PRINT("sys_timerfd_settime ( %ld, %ld, %#" FMT_REGWORD "x, %#"

@@ -2968,6 +3272,34 @@

       POST_MEM_WRITE(ARG4, sizeof(struct vki_itimerspec));

 }

+PRE(sys_timerfd_settime64)

+{

+   PRINT("sys_timerfd_settime64 ( %ld, %ld, %#" FMT_REGWORD "x, %#"

+         FMT_REGWORD "x )", SARG1, SARG2, ARG3, ARG4);

+   PRE_REG_READ4(long, "timerfd_settime64",

+                 int, ufd,

+                 int, flags,

+                 const struct vki_itimerspec64*, utmr,

+                 struct vki_itimerspec64*, otmr);

+   if (!ML_(fd_allowed)(ARG1, "timerfd_settime64", tid, False))

+      SET_STATUS_Failure(VKI_EBADF);

+   else

+   {

+      PRE_MEM_READ("timerfd_settime64(result)",

+                   ARG3, sizeof(struct vki_itimerspec64));

+      if (ARG4)

+      {

+         PRE_MEM_WRITE("timerfd_settime64(result)",

+                       ARG4, sizeof(struct vki_itimerspec64));

+      }

+   }

+}

+POST(sys_timerfd_settime64)

+{

+   if (RES == 0 && ARG4 != 0)

+      POST_MEM_WRITE(ARG4, sizeof(struct vki_itimerspec64));

+}

+

 /* ---------------------------------------------------------------------

    capabilities wrappers

    ------------------------------------------------------------------ */

@@ -3350,6 +3682,22 @@

    POST_MEM_WRITE(ARG2, sizeof(struct vki_timespec));

 }

+PRE(sys_sched_rr_get_interval_time64)

+{

+   PRINT("sys_sched_rr_get_interval_time64 ( %ld, %#" FMT_REGWORD "x )",

+         SARG1, ARG2);

+   PRE_REG_READ2(int, "sched_rr_get_interval_time64",

+                 vki_pid_t, pid,

+                 struct vki_timespec *, tp);

+   PRE_MEM_WRITE("sched_rr_get_interval_time64(timespec)",

+                 ARG2, sizeof(struct vki_timespec64));

+}

+

+POST(sys_sched_rr_get_interval_time64)

+{

+   POST_MEM_WRITE(ARG2, sizeof(struct vki_timespec64));

+}

+

 PRE(sys_sched_setaffinity)

 {

    PRINT("sched_setaffinity ( %ld, %" FMT_REGWORD "u, %#" FMT_REGWORD "x )",

@@ -4067,6 +4415,31 @@

       POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );

 }

+PRE(sys_rt_sigtimedwait_time64)

+{

+   *flags |= SfMayBlock;

+   PRINT("sys_rt_sigtimedwait_time64 ( %#" FMT_REGWORD "x, %#"

+         FMT_REGWORD "x, %#" FMT_REGWORD "x, %" FMT_REGWORD "u )",

+         ARG1, ARG2, ARG3, ARG4);

+   PRE_REG_READ4(long, "rt_sigtimedwait_time64", 

+                 const vki_sigset_t *, set, vki_siginfo_t *, info,

+                 const struct vki_timespec64 *, timeout,

+                 vki_size_t, sigsetsize);

+   if (ARG1 != 0) 

+      PRE_MEM_READ( "rt_sigtimedwait_time64(set)", ARG1, sizeof(vki_sigset_t) );

+   if (ARG2 != 0)

+      PRE_MEM_WRITE( "rt_sigtimedwait_time64(info)", ARG2,

+                     sizeof(vki_siginfo_t) );

+   if (ARG3 != 0)

+      PRE_MEM_READ( "rt_sigtimedwait_time64(timeout)",

+                    ARG3, sizeof(struct vki_timespec64) );

+}

+POST(sys_rt_sigtimedwait_time64)

+{

+   if (ARG2 != 0)

+      POST_MEM_WRITE( ARG2, sizeof(vki_siginfo_t) );

+}

+

 PRE(sys_rt_sigqueueinfo)

 {

    PRINT("sys_rt_sigqueueinfo(%ld, %ld, %#" FMT_REGWORD "x)",

@@ -4515,6 +4888,21 @@

    ML_(generic_PRE_sys_semtimedop)(tid, ARG1,ARG2,ARG3,ARG4);

 }

+PRE(sys_semtimedop_time64)

+{

+   *flags |= SfMayBlock;

+   PRINT("sys_semtimedop_time64 ( %ld, %#" FMT_REGWORD "x, %"

+         FMT_REGWORD "u, %#" FMT_REGWORD "x )", SARG1, ARG2, ARG3, ARG4);

+   PRE_REG_READ4(long, "semtimedop_time64",

+                 int, semid, struct sembuf *, sops, unsigned, nsoops,

+                 struct vki_timespec64 *, timeout);

+   PRE_MEM_READ( "semtimedop_time64(sops)", ARG1,

+                 ARG2 * sizeof(struct vki_sembuf) );

+   if (ARG3 != 0)

+      PRE_MEM_READ( "semtimedop_time64(timeout)", ARG3,

+                    sizeof(struct vki_timespec64) );

+}

+

 PRE(sys_msgget)

 {

    PRINT("sys_msgget ( %ld, %ld )", SARG1, SARG2);

@@ -5324,6 +5712,36 @@

    }

 }

+PRE(sys_utimensat_time64)

+{

+   PRINT("sys_utimensat_time64 ( %ld, %#" FMT_REGWORD "x(%s), %#"

+         FMT_REGWORD "x, 0x%" FMT_REGWORD "x )",

+         SARG1, ARG2, (HChar*)(Addr)ARG2, ARG3, ARG4);

+   PRE_REG_READ4(long, "utimensat_time64",

+                 int, dfd, char *, filename, struct timespec *, utimes, int, flags);

+   if (ARG2 != 0)

+      PRE_MEM_RASCIIZ( "utimensat_time64(filename)", ARG2 );

+   if (ARG3 != 0) {

+      /* If timespec.tv_nsec has the special value UTIME_NOW or UTIME_OMIT

+         then the tv_sec field is ignored.  */

+      struct vki_timespec64 *times = (struct vki_timespec64 *)(Addr)ARG3;

+      PRE_MEM_READ( "utimensat_time64(times[0].tv_nsec)",

+                    (Addr)&times[0].tv_nsec, sizeof(times[0].tv_nsec));

+      PRE_MEM_READ( "utimensat_time64(times[1].tv_nsec)",

+                    (Addr)&times[1].tv_nsec, sizeof(times[1].tv_nsec));

+      if (ML_(safe_to_deref)(times, 2 * sizeof(struct vki_timespec64))) {

+         if (times[0].tv_nsec != VKI_UTIME_NOW

+             && times[0].tv_nsec != VKI_UTIME_OMIT)

+            PRE_MEM_READ( "utimensat_time64(times[0].tv_sec)",

+                          (Addr)&times[0].tv_sec, sizeof(times[0].tv_sec));

+         if (times[1].tv_nsec != VKI_UTIME_NOW

+             && times[1].tv_nsec != VKI_UTIME_OMIT)

+            PRE_MEM_READ( "utimensat_time64(times[1].tv_sec)",

+                          (Addr)&times[1].tv_sec, sizeof(times[1].tv_sec));

+      }

+   }

+}

+

 PRE(sys_newfstatat)

 {

    FUSE_COMPATIBLE_MAY_BLOCK();

@@ -5816,6 +6234,34 @@

    ML_(linux_POST_sys_recvmmsg) (tid, RES, ARG1,ARG2,ARG3,ARG4,ARG5);

 }

+PRE(sys_recvmmsg_time64)

+{

+   *flags |= SfMayBlock;

+   PRINT("sys_recvmmsg_time64 ( %ld, %#" FMT_REGWORD "x, %ld, %ld, %#"

+         FMT_REGWORD "x )",

+         SARG1, ARG2, SARG3, SARG4, ARG5);

+   PRE_REG_READ5(long, "recvmmsg_time64",

+                 int, s, struct mmsghdr *, mmsg, int, vlen,

+                 int, flags, struct vki_timespec64 *, timeout);

+   struct vki_mmsghdr *mmsg = (struct vki_mmsghdr *)ARG2;

+   HChar name[40];     // large enough

+   UInt i;

+   for (i = 0; i < ARG3; i++) {

+      VG_(sprintf)(name, "mmsg[%u].msg_hdr", i);

+      ML_(generic_PRE_sys_recvmsg)(tid, name, &mmsg[i].msg_hdr);

+      VG_(sprintf)(name, "recvmmsg(mmsg[%u].msg_len)", i);

+      PRE_MEM_WRITE( name, (Addr)&mmsg[i].msg_len, sizeof(mmsg[i].msg_len) );

+   }

+   if (ARG5)

+      PRE_MEM_READ( "recvmmsg(timeout)", ARG5, sizeof(struct vki_timespec64) );

+}

+

+POST(sys_recvmmsg_time64)

+{

+   /* ARG5 isn't actually used, so just use the generic POST. */

+   ML_(linux_POST_sys_recvmmsg) (tid, RES, ARG1,ARG2,ARG3,ARG4,ARG5);

+}

+

 /* ---------------------------------------------------------------------

    key retention service wrappers

    ------------------------------------------------------------------ */

@@ -12312,3 +12758,4 @@

 /*--------------------------------------------------------------------*/

 /*--- end                                                          ---*/

 /*--------------------------------------------------------------------*/

+

diff -ur valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-mips32-linux.c valgrind-3.15.0/coregrind/m_syswrap/syswrap-mips32-linux.c

--- valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-mips32-linux.c	2019-04-13 12:56:21.000000000 +0200

+++ valgrind-3.15.0/coregrind/m_syswrap/syswrap-mips32-linux.c	2020-02-28 15:48:55.507851274 +0100

@@ -1066,7 +1066,29 @@

    //..

    LINX_(__NR_membarrier,              sys_membarrier),              // 358

    //..

-   LINXY(__NR_statx,                   sys_statx)                    // 366

+   LINXY(__NR_statx,                   sys_statx),                   // 366

+

+   LINXY(__NR_clock_gettime64,         sys_clock_gettime64),         // 403

+   LINX_(__NR_clock_settime64,         sys_clock_settime64),         // 404

+

+   LINXY(__NR_clock_getres_time64,     sys_clock_getres_time64),     // 406

+   LINXY(__NR_clock_nanosleep_time64,  sys_clock_nanosleep_time64),  // 407

+   LINXY(__NR_timer_gettime64,         sys_timer_gettime64),         // 408

+   LINXY(__NR_timer_settime64,         sys_timer_settime64),         // 409

+   LINXY(__NR_timerfd_gettime64,       sys_timerfd_gettime64),       // 410

+   LINXY(__NR_timerfd_settime64,       sys_timerfd_settime64),       // 411

+   LINX_(__NR_utimensat_time64,        sys_utimensat_time64),        // 412

+   LINXY(__NR_pselect6_time64,         sys_pselect6_time64),         // 413

+   LINXY(__NR_ppoll_time64,            sys_ppoll_time64),            // 414

+

+   LINXY(__NR_recvmmsg_time64,         sys_recvmmsg_time64),         // 417

+   LINX_(__NR_mq_timedsend_time64,     sys_mq_timedsend_time64),     // 418

+   LINXY(__NR_mq_timedreceive_time64,  sys_mq_timedreceive_time64),  // 419

+   LINX_(__NR_semtimedop_time64,       sys_semtimedop_time64),       // 420

+   LINXY(__NR_rt_sigtimedwait_time64,  sys_rt_sigtimedwait_time64),  // 421

+   LINXY(__NR_futex_time64,            sys_futex_time64),            // 422

+   LINXY(__NR_sched_rr_get_interval_time64,

+         sys_sched_rr_get_interval_time64),                          // 423

 };

 SyscallTableEntry* ML_(get_linux_syscall_entry) (UInt sysno)

diff -ur valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-ppc32-linux.c valgrind-3.15.0/coregrind/m_syswrap/syswrap-ppc32-linux.c

--- valgrind-3.15.0.orig/coregrind/m_syswrap/syswrap-ppc32-linux.c	2020-02-28 14:02:29.809342221 +0100

+++ valgrind-3.15.0/coregrind/m_syswrap/syswrap-ppc32-linux.c	2020-02-28 14:55:44.626692770 +0100

@@ -1024,6 +1024,28 @@

    LINX_(__NR_copy_file_range,   sys_copy_file_range),  // 379

    LINXY(__NR_statx,             sys_statx),            // 383

+

+   LINXY(__NR_clock_gettime64,   sys_clock_gettime64),  // 403

+   LINX_(__NR_clock_settime64,   sys_clock_settime64),  // 404

+

+   LINXY(__NR_clock_getres_time64, sys_clock_getres_time64), // 406

+   LINXY(__NR_clock_nanosleep_time64, sys_clock_nanosleep_time64), // 407

+   LINXY(__NR_timer_gettime64,   sys_timer_gettime64),  // 408

+   LINXY(__NR_timer_settime64,   sys_timer_settime64),  // 409

+   LINXY(__NR_timerfd_gettime64, sys_timerfd_gettime64),// 410

+   LINXY(__NR_timerfd_settime64, sys_timerfd_settime64),// 411

+   LINX_(__NR_utimensat_time64,  sys_utimensat_time64), // 412