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__)
+    /* x32 has 32bit longs, but the syscall interface is 64bit */
+    #ifdef __ILP32__
+    #define LSS_SC_ARG(a) (sizeof(a) == 8 ? \

[Mark Seaborn, 2013/02/28 17:46:53]

"SC" is rather cryptic.  Maybe "LSS_SYSCALL_ARG" instead?

[vapier, 2013/02/28 21:51:48]

Done.

+                           (unsigned long long)(a) : \
+                           (unsigned long long)(uintptr_t)(a))

[Mark Seaborn, 2013/02/28 17:46:53]

I don't understand why you have a double cast here, and why it's conditional. 
Is it anything to do with avoiding warnings?

Also, it might be clearer and more concise to use uint64_t rather than 'unsigned
long long'.

[vapier, 2013/02/28 21:51:48]

on x32, pointers are 32bit.  syscall args are 64bit.  you can't cast from a
pointer type to a 64bit integer type straight or you'll get a lot of warnings. 
you might also get incorrect sign extension (i saw a bit of this when
developing/testing, but i'd have to go back and come up with an exact example --
the mmap() test in the other CL shows it easily).

so we bring in uintptr_t to take care of converting sanely (and warning free)
from a pointer to an int, and then we cast it up to unsigned long long to get
our 64bit quantity.

we can't always cast the value to uintptr_t because that's a 32bit quantity and
we could easily truncate an existing 64bit value which would be bad.

i picked 'unsigned long long' simply because that was what the existing code
uses.  i can convert it to uint64_t.

[Mark Seaborn, 2013/03/01 23:15:40]

I don't think using ?: is going to protect you from the warnings.  If you're on
x32, gcc will complain about the cast to "unsigned long long" being a size
mismatch even if you want that side of the conditional to be compiled out.

If you don't mind the compiler warnings (as you say in the commit message), then
can't you do the following unconditionally? --

#define LS_SYSCALL_ARG(a) ((uint64_t)(a))
Hmm, won't casting to "unsigned long long" give you zero-extension?

[vapier, 2013/03/01 23:21:49]

sure, i didn't mean to indicate it does entirely save me :).  i highlighted in
the commit message that this still warns.  but using the uintptr_t cast cuts the
# in half.

unconditionally casting to (uint64_t) triggers the warnings i mentioned earlier:

$ echo 'int main() { return (unsigned long long)main; }' | \
  gcc -xc - -o /dev/null  -Wall -mx32 -c
<stdin>: In function ‘main’:
<stdin>:1:21: warning: cast from pointer to integer of different size
[-Wpointer-to-int-cast]

unconditionally casting to uintptr_t avoids warnings, but silently truncates
64bit quantities :(

[Mark Seaborn, 2013/03/04 16:52:44]

Having extra code that only reduces the number of warnings but doesn't eliminate
them doesn't seem worthwhile to me.  At least, if you're going to do that it
needs a comment in the code.

Is there a way you can fix all the warnings?

In newer GCC versions you can suppress the warning with this:

  _Pragma("GCC diagnostic push");
  /* Suppress complaints about casting a pointer to an integer of a different
size. */
  _Pragma("GCC diagnostic ignored \"-Wpointer-to-int-cast\"");
  uint64_t x1 = (uint64_t) (void *) 0;
  _Pragma("GCC diagnostic pop");

The older GCC in Ubuntu Lucid only allows this _Pragma at top level, but if
you're using x32 I expect you can assume a newer GCC.

+    #else
+    #define LSS_SC_ARG(a) (long)(a)

[Mark Seaborn, 2013/02/28 17:46:53]

Should this be "((long)(a))"?

[vapier, 2013/02/28 21:51:48]

it could be.  in practice it doesn't matter.  i'll change it.

+    #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;                                                    \
           __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_SC_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_SC_ARG(arg1)), "S" (LSS_SC_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_SC_ARG(arg1)), "S" (LSS_SC_ARG(arg2)),  \
+                             "d" (LSS_SC_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;                                                         \
           __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_SC_ARG(arg1)), "S" (LSS_SC_ARG(arg2)),                   \
+            "d" (LSS_SC_ARG(arg3)), "r" (LSS_SC_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;                                                         \
           __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_SC_ARG(arg1)), "S" (LSS_SC_ARG(arg2)),                   \
+            "d" (LSS_SC_ARG(arg3)), "r" (LSS_SC_ARG(arg4)),                   \
+            "r" (LSS_SC_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;                                                         \
           __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_SC_ARG(arg1)), "S" (LSS_SC_ARG(arg2)),                   \
+            "d" (LSS_SC_ARG(arg3)), "r" (LSS_SC_ARG(arg4)),                   \
+            "r" (LSS_SC_ARG(arg5)), "r" (LSS_SC_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;
       {
         __asm__ __volatile__(/* if (fn == NULL)
                               *   return -EINVAL;
                               */
@@ skipping 48 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_SC_ARG(fn)), "S"(LSS_SC_ARG(child_stack)),

[Mark Seaborn, 2013/02/28 17:46:53]

Line is >80 characters.  Please put the arguments on separate lines.

[vapier, 2013/02/28 21:51:48]

Done.

+                               "D"(LSS_SC_ARG(flags)), "r"(LSS_SC_ARG(arg)),
+                               "d"(LSS_SC_ARG(parent_tidptr)), "r"(LSS_SC_ARG(newtls)),

[Mark Seaborn, 2013/02/28 17:46:53]

Same here.

[vapier, 2013/02/28 21:51:48]

Done.

+                               "r"(LSS_SC_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
@@ skipping 1600 matching lines @@
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif