Fix for x64 Android. __unused is #defined elsewhere.

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 408 matching lines @@
   uint64_t           st_rdev;
   int64_t            st_size;
   int64_t            st_blksize;
   int64_t            st_blocks;
   uint64_t           st_atime_;
   uint64_t           st_atime_nsec_;
   uint64_t           st_mtime_;
   uint64_t           st_mtime_nsec_;
   uint64_t           st_ctime_;
   uint64_t           st_ctime_nsec_;
-  int64_t            __unused[3];
+  int64_t            __unused4[3];
 };
 #elif defined(__PPC__)
 struct kernel_stat {
   unsigned           st_dev;
   unsigned long      st_ino;      // ino_t
   unsigned long      st_mode;     // mode_t
   unsigned short     st_nlink;    // nlink_t
   unsigned           st_uid;      // uid_t
   unsigned           st_gid;      // gid_t
   unsigned           st_rdev;
@@ skipping 1794 matching lines @@
       long __res;
       {
         register int   __flags __asm__("r0") = flags;
         register void *__stack __asm__("r1") = child_stack;
         register void *__ptid  __asm__("r2") = parent_tidptr;
         register void *__tls   __asm__("r3") = newtls;
         register int  *__ctid  __asm__("r4") = child_tidptr;
         __asm__ __volatile__(/* if (fn == NULL || child_stack == NULL)
                               *   return -EINVAL;
                               */
-#ifdef __thumb2__                            
+#ifdef __thumb2__
                              "push  {r7}\n"
-#endif                       
+#endif
                              "cmp   %2,#0\n"
                              "it    ne\n"
                              "cmpne %3,#0\n"
                              "it    eq\n"
                              "moveq %0,%1\n"
                              "beq   1f\n"
 
                              /* Push "arg" and "fn" onto the stack that will be
                               * used by the child.
                               */
@@ skipping 37 matching lines @@
                              "ldr   pc,[sp]\n"
                            #endif
 
                              /* Call _exit(%r0).
                               */
                              "mov r7, %10\n"
                              "swi 0x0\n"
                            "1:\n"
 #ifdef __thumb2__
                              "pop {r7}"
-#endif                       
+#endif
                              : "=r" (__res)
                              : "i"(-EINVAL),
                                "r"(fn), "r"(__stack), "r"(__flags), "r"(arg),
                                "r"(__ptid), "r"(__tls), "r"(__ctid),
                                "i"(__NR_clone), "i"(__NR_exit)
 #ifdef __thumb2__
                              : "cc", "lr", "memory");
 #else
                              : "cc", "r7", "lr", "memory");
 #endif
@@ skipping 608 matching lines @@
     }
 
     LSS_INLINE int LSS_NAME(getresuid32)(uid_t *ruid,
                                          uid_t *euid,
                                          uid_t *suid) {
       return LSS_NAME(getresuid)(ruid, euid, suid);
     }
 
     /* Need to make sure __off64_t isn't truncated to 32-bits under x32.  */
     LSS_INLINE void* LSS_NAME(mmap)(void *s, size_t l, int p, int f, int d,
+#ifdef __ANDROID__
+     // Recent versions of NDK do not define __off64_t, where as Linux
+     // only defines off64_t if __USE_LARGEFILE64 is defined.
+                                     off64_t o) {

[Mark Seaborn, 2014/04/02 17:27:37]

How about just using int64_t here?

+#else
                                     __off64_t o) {
+#endif
       LSS_BODY(6, void*, mmap, LSS_SYSCALL_ARG(s), LSS_SYSCALL_ARG(l),
                                LSS_SYSCALL_ARG(p), LSS_SYSCALL_ARG(f),
                                LSS_SYSCALL_ARG(d), (uint64_t)(o));
     }
 
     LSS_INLINE _syscall4(int, newfstatat,         int,   d,
                          const char *,            p,
                         struct kernel_stat*,       b, int, f)
 
     LSS_INLINE int LSS_NAME(setfsgid32)(gid_t gid) {
@@ skipping 721 matching lines @@
 # pragma pop_macro("fstat64")
 # pragma pop_macro("lstat64")
 #endif
 
 #if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
 }
 #endif
 
 #endif
 #endif