add x32 ABI support

lss/linux_syscall_support.h

 /* Copyright (c) 2005-2011, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 85 matching lines @@
  * multiple nested 'extern "C"' blocks, just add another one here.
  */
 extern "C" {
 #endif
 
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 #include <sys/ptrace.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 #include <linux/unistd.h>
 #include <endian.h>
 
@@ skipping 1630 matching lines @@
                          "1:pop    %%eax\n"
                            "movl   %1,%%eax\n"
                            LSS_ENTRYPOINT
                          "2:popl   %0\n"
                            "addl   $(1b-0b),%0\n"
                            : "=a" (res)
                            : "i"  (__NR_sigreturn));
       return res;
     }
   #elif defined(__x86_64__)
+    /* The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
+     * We need to explicitly cast to an unsigned 64 bit type to avoid implicit
+     * sign extension.  We can't cast pointers directly because those are
+     * 32 bits, and gcc will dump ugly warnings about casting from a pointer
+     * to an integer of a different size.
+     */
+    #ifdef __ILP32__
+    #define LSS_SYSCALL_IGNORE_ARG_CASTS()                                    \
+      do {                                                                    \
+        _Pragma("GCC diagnostic ignored \"-Wpointer-to-int-cast\"");          \

[Mark Seaborn, 2013/03/05 17:05:19]

You also need to do "GCC diagnostic push"/"pop" otherwise this will leak out and
disable the warning for the whole compilation unit.

Maybe you want a macro like this:

#define CAST_TO_UINT64(x) \
  ({ uint64_t _tmp; \
     _Pragma("GCC diagnostic push"); \
     _Pragma("GCC diagnostic ignored \"-Wpointer-to-int-cast\""); \
     _tmp = (x); \
     _Pragma("GCC diagnostic pop"); \
     _tmp; \
   })

I worry that this will fall foul of stricter GCC warnings that complain about
GCC extensions like the "({...})" syntax. :-/  But maybe we shouldn't worry
about those warnings.

+        _Pragma("GCC diagnostic ignored \"-Wint-to-pointer-cast\"");          \
+      } while (0)
+    #define LSS_SYSCALL_ARG(a) (sizeof(a) == 8 ? \

[Mark Seaborn, 2013/03/05 17:05:19]

If you're disabling the warning, you don't need this conditional any more,
right?  LSS_SYSCALL_ARG(a) can be ((uint64_t)(a)) unconditionally.

+                                (uint64_t)(a) : \
+                                (uint64_t)(uintptr_t)(a))
+    #undef LSS_RETURN
+    #define LSS_RETURN(type, res)                                             \
+      do {                                                                    \
+        if ((uint64_t)(res) >= (uint64_t)(-4095)) {                           \
+          LSS_ERRNO = -(res);                                                 \
+          res = -1;                                                           \
+        }                                                                     \
+        LSS_SYSCALL_IGNORE_ARG_CASTS();                                       \
+        return (type) (res);                                                  \
+      } while (0)
+    #else
+    #define LSS_SYSCALL_IGNORE_ARG_CASTS()
+    #define LSS_SYSCALL_ARG(a) ((long)(a))
+    #endif
+
     /* There are no known problems with any of the _syscallX() macros
      * currently shipping for x86_64, but we still need to be able to define
      * our own version so that we can override the location of the errno
      * location (e.g. when using the clone() system call with the CLONE_VM
      * option).
      */
     #undef LSS_ENTRYPOINT
     #ifdef SYS_SYSCALL_ENTRYPOINT
     static inline void (**LSS_NAME(get_syscall_entrypoint)(void))(void) {
       void (**entrypoint)(void);
@@ skipping 20 matching lines @@
               "call *%%rcx\n"                                                 \
               "jmp  10002f\n"                                                 \
         "10001:syscall\n"                                                     \
         "10002:\n"
 
     #else
     #define LSS_ENTRYPOINT "syscall\n"
     #endif
     #undef  LSS_BODY
     #define LSS_BODY(type,name, ...)                                          \
-          long __res;                                                         \
+          long long __res;                                                    \
+          LSS_SYSCALL_IGNORE_ARG_CASTS();                                     \
           __asm__ __volatile__(LSS_ENTRYPOINT                                 \
             : "=a" (__res) : "0" (__NR_##name),                               \
             ##__VA_ARGS__ : "r11", "rcx", "memory");                          \
           LSS_RETURN(type, __res)
     #undef _syscall0
     #define _syscall0(type,name)                                              \
       type LSS_NAME(name)(void) {                                             \
         LSS_BODY(type, name);                                                 \
       }
     #undef _syscall1
     #define _syscall1(type,name,type1,arg1)                                   \
       type LSS_NAME(name)(type1 arg1) {                                       \
-        LSS_BODY(type, name, "D" ((long)(arg1)));                             \
+        LSS_BODY(type, name, "D" (LSS_SYSCALL_ARG(arg1)));                    \
       }
     #undef _syscall2
     #define _syscall2(type,name,type1,arg1,type2,arg2)                        \
       type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)));         \
+        LSS_BODY(type, name, "D" (LSS_SYSCALL_ARG(arg1)),                     \
+                             "S" (LSS_SYSCALL_ARG(arg2)));                    \
       }
     #undef _syscall3
     #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \
       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)),          \
-                             "d" ((long)(arg3)));                             \
+        LSS_BODY(type, name, "D" (LSS_SYSCALL_ARG(arg1)),                     \
+                             "S" (LSS_SYSCALL_ARG(arg2)),                     \
+                             "d" (LSS_SYSCALL_ARG(arg3)));                    \
       }
     #undef _syscall4
     #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \
       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
-          long __res;                                                         \
+          long long __res;                                                    \
+          LSS_SYSCALL_IGNORE_ARG_CASTS();                                     \
           __asm__ __volatile__("movq %5,%%r10;" LSS_ENTRYPOINT :              \
             "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)) : "r10", "r11", "rcx", "memory");              \
+            "D" (LSS_SYSCALL_ARG(arg1)), "S" (LSS_SYSCALL_ARG(arg2)),         \
+            "d" (LSS_SYSCALL_ARG(arg3)), "r" (LSS_SYSCALL_ARG(arg4))          \
+            : "r10", "r11", "rcx", "memory");                                 \
           LSS_RETURN(type, __res);                                            \
       }
     #undef _syscall5
     #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
                       type5,arg5)                                             \
       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
                           type5 arg5) {                                       \
-          long __res;                                                         \
+          long long __res;                                                    \
+          LSS_SYSCALL_IGNORE_ARG_CASTS();                                     \
           __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8;" LSS_ENTRYPOINT :\
             "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)), "r" ((long)(arg5)) :                          \
-            "r8", "r10", "r11", "rcx", "memory");                             \
+            "D" (LSS_SYSCALL_ARG(arg1)), "S" (LSS_SYSCALL_ARG(arg2)),         \
+            "d" (LSS_SYSCALL_ARG(arg3)), "r" (LSS_SYSCALL_ARG(arg4)),         \
+            "r" (LSS_SYSCALL_ARG(arg5)) : "r8", "r10", "r11", "rcx",          \
+            "memory");                                                        \
           LSS_RETURN(type, __res);                                            \
       }
     #undef _syscall6
     #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
                       type5,arg5,type6,arg6)                                  \
       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
                           type5 arg5, type6 arg6) {                           \
-          long __res;                                                         \
+          long long __res;                                                    \
+          LSS_SYSCALL_IGNORE_ARG_CASTS();                                     \
           __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; movq %7,%%r9;"   \
                                LSS_ENTRYPOINT :                               \
             "=a" (__res) : "0" (__NR_##name),                                 \
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
-            "r" ((long)(arg4)), "r" ((long)(arg5)), "r" ((long)(arg6)) :      \
-            "r8", "r9", "r10", "r11", "rcx", "memory");                       \
+            "D" (LSS_SYSCALL_ARG(arg1)), "S" (LSS_SYSCALL_ARG(arg2)),         \
+            "d" (LSS_SYSCALL_ARG(arg3)), "r" (LSS_SYSCALL_ARG(arg4)),         \
+            "r" (LSS_SYSCALL_ARG(arg5)), "r" (LSS_SYSCALL_ARG(arg6))          \
+            : "r8", "r9", "r10", "r11", "rcx", "memory");                     \
           LSS_RETURN(type, __res);                                            \
       }
     LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
                                    int flags, void *arg, int *parent_tidptr,
                                    void *newtls, int *child_tidptr) {
-      long __res;
+      long long __res;
       {
+        LSS_SYSCALL_IGNORE_ARG_CASTS();
         __asm__ __volatile__(/* if (fn == NULL)
                               *   return -EINVAL;
                               */
                              "testq  %4,%4\n"
                              "jz     1f\n"
 
                              /* if (child_stack == NULL)
                               *   return -EINVAL;
                               */
                              "testq  %5,%5\n"
@@ skipping 41 matching lines @@
                               */
                              "movq   %%rax,%%rdi\n"
                              "movq   %3,%%rax\n"
                              LSS_ENTRYPOINT
 
                              /* Return to parent.
                               */
                            "1:\n"
                              : "=a" (__res)
                              : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
-                               "r"(fn), "S"(child_stack), "D"(flags), "r"(arg),
-                               "d"(parent_tidptr), "r"(newtls),
-                               "r"(child_tidptr)
+                               "r"(LSS_SYSCALL_ARG(fn)),
+                               "S"(LSS_SYSCALL_ARG(child_stack)),
+                               "D"(LSS_SYSCALL_ARG(flags)),
+                               "r"(LSS_SYSCALL_ARG(arg)),
+                               "d"(LSS_SYSCALL_ARG(parent_tidptr)),
+                               "r"(LSS_SYSCALL_ARG(newtls)),
+                               "r"(LSS_SYSCALL_ARG(child_tidptr))
                              : "rsp", "memory", "r8", "r10", "r11", "rcx");
       }
       LSS_RETURN(int, __res);
     }
     LSS_INLINE _syscall2(int, arch_prctl, int, c, void *, a)
     LSS_INLINE _syscall4(int, fadvise64, int, fd, loff_t, offset, loff_t, len,
                          int,  advice)
 
     LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
       /* On x86-64, the kernel does not know how to return from
        * a signal handler. Instead, it relies on user space to provide a
        * restorer function that calls the rt_sigreturn() system call.
        * Unfortunately, we cannot just reference the glibc version of this
        * function, as glibc goes out of its way to make it inaccessible.
        */
-      void (*res)(void);
+      long long res;
       __asm__ __volatile__("call   2f\n"
                          "0:.align 16\n"
                          "1:movq   %1,%%rax\n"
                            LSS_ENTRYPOINT
                          "2:popq   %0\n"
                            "addq   $(1b-0b),%0\n"
                            : "=a" (res)
                            : "i"  (__NR_rt_sigreturn));
-      return res;
+      return (void (*)())(uintptr_t)res;
     }
   #elif defined(__ARM_ARCH_3__)
     /* Most definitions of _syscallX() neglect to mark "memory" as being
      * clobbered. This causes problems with compilers, that do a better job
      * at optimizing across __asm__ calls.
      * So, we just have to redefine all of the _syscallX() macros.
      */
     #undef LSS_REG
     #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a
     #undef  LSS_BODY
@@ skipping 1575 matching lines @@
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif