* Android: Include list of supported syscalls for each CPU.

  Adjust Linux RTL to work with supported Android syscalls. 
  It should fix issues with Android 8.

git-svn-id: trunk@37480 -

.gitattributes

@@ -8603,10 +8603,12 @@ rtl/android/Makefile svneol=native#text/plain
 rtl/android/Makefile.fpc svneol=native#text/plain
 rtl/android/arm/dllprt0.as svneol=native#text/plain
 rtl/android/arm/prt0.as svneol=native#text/plain
+rtl/android/arm/sysnr.inc svneol=native#text/plain
 rtl/android/cwstring.pp svneol=native#text/plain
 rtl/android/dlandroid.inc svneol=native#text/plain
 rtl/android/i386/dllprt0.as svneol=native#text/plain
 rtl/android/i386/prt0.as svneol=native#text/plain
+rtl/android/i386/sysnr.inc svneol=native#text/plain
 rtl/android/jvm/Makefile svneol=native#text/plain
 rtl/android/jvm/Makefile.fpc svneol=native#text/plain
 rtl/android/jvm/androidr14.inc svneol=native#text/plain
@@ -8616,6 +8618,7 @@ rtl/android/jvm/java_sysh_android.inc svneol=native#text/plain
 rtl/android/jvm/rtl.cfg svneol=native#text/plain
 rtl/android/mipsel/dllprt0.as svneol=native#text/plain
 rtl/android/mipsel/prt0.as svneol=native#text/plain
+rtl/android/mipsel/sysnr.inc svneol=native#text/plain
 rtl/android/sysandroid.inc svneol=native#text/plain
 rtl/android/sysandroidh.inc svneol=native#text/plain
 rtl/android/unixandroid.inc svneol=native#text/plain

rtl/android/arm/sysnr.inc

@@ -0,0 +1,217 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2017 by Yuriy Sydorov,
+    member of the Free Pascal development team.
+
+    Syscall nrs for arm-android
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+const
+  __NR_SYSCALL_BASE = 0;
+
+syscall_nr_exit                         = (__NR_SYSCALL_BASE + 1);
+syscall_nr_fork                         = (__NR_SYSCALL_BASE + 2);
+syscall_nr_read                         = (__NR_SYSCALL_BASE + 3);
+syscall_nr_write                        = (__NR_SYSCALL_BASE + 4);
+syscall_nr_open                         = (__NR_SYSCALL_BASE + 5);
+syscall_nr_close                        = (__NR_SYSCALL_BASE + 6);
+syscall_nr_link                         = (__NR_SYSCALL_BASE + 9);
+syscall_nr_unlink                       = (__NR_SYSCALL_BASE + 10);
+syscall_nr_execve                       = (__NR_SYSCALL_BASE + 11);
+syscall_nr_chdir                        = (__NR_SYSCALL_BASE + 12);
+syscall_nr_mknod                        = (__NR_SYSCALL_BASE + 14);
+syscall_nr_chmod                        = (__NR_SYSCALL_BASE + 15);
+syscall_nr_lseek                        = (__NR_SYSCALL_BASE + 19);
+syscall_nr_getpid                       = (__NR_SYSCALL_BASE + 20);
+syscall_nr_mount                        = (__NR_SYSCALL_BASE + 21);
+syscall_nr_ptrace                       = (__NR_SYSCALL_BASE + 26);
+syscall_nr_pause                        = (__NR_SYSCALL_BASE + 29);
+syscall_nr_access                       = (__NR_SYSCALL_BASE + 33);
+syscall_nr_sync                         = (__NR_SYSCALL_BASE + 36);
+syscall_nr_rename                       = (__NR_SYSCALL_BASE + 38);
+syscall_nr_mkdir                        = (__NR_SYSCALL_BASE + 39);
+syscall_nr_rmdir                        = (__NR_SYSCALL_BASE + 40);
+syscall_nr_dup                          = (__NR_SYSCALL_BASE + 41);
+syscall_nr_times                        = (__NR_SYSCALL_BASE + 43);
+syscall_nr_brk                          = (__NR_SYSCALL_BASE + 45);
+syscall_nr_acct                         = (__NR_SYSCALL_BASE + 51);
+syscall_nr_umount2                      = (__NR_SYSCALL_BASE + 52);
+syscall_nr_ioctl                        = (__NR_SYSCALL_BASE + 54);
+syscall_nr_fcntl                        = (__NR_SYSCALL_BASE + 55);
+syscall_nr_setpgid                      = (__NR_SYSCALL_BASE + 57);
+syscall_nr_umask                        = (__NR_SYSCALL_BASE + 60);
+syscall_nr_chroot                       = (__NR_SYSCALL_BASE + 61);
+syscall_nr_dup2                         = (__NR_SYSCALL_BASE + 63);
+syscall_nr_getppid                      = (__NR_SYSCALL_BASE + 64);
+syscall_nr_setsid                       = (__NR_SYSCALL_BASE + 66);
+syscall_nr_sigaction                    = (__NR_SYSCALL_BASE + 67);
+syscall_nr_sigpending                   = (__NR_SYSCALL_BASE + 73);
+syscall_nr_setrlimit                    = (__NR_SYSCALL_BASE + 75);
+syscall_nr_getrusage                    = (__NR_SYSCALL_BASE + 77);
+syscall_nr_gettimeofday                 = (__NR_SYSCALL_BASE + 78);
+syscall_nr_settimeofday                 = (__NR_SYSCALL_BASE + 79);
+syscall_nr_symlink                      = (__NR_SYSCALL_BASE + 83);
+syscall_nr_readlink                     = (__NR_SYSCALL_BASE + 85);
+syscall_nr_reboot                       = (__NR_SYSCALL_BASE + 88);
+syscall_nr_munmap                       = (__NR_SYSCALL_BASE + 91);
+syscall_nr_truncate                     = (__NR_SYSCALL_BASE + 92);
+syscall_nr_ftruncate                    = (__NR_SYSCALL_BASE + 93);
+syscall_nr_fchmod                       = (__NR_SYSCALL_BASE + 94);
+syscall_nr_getpriority                  = (__NR_SYSCALL_BASE + 96);
+syscall_nr_setpriority                  = (__NR_SYSCALL_BASE + 97);
+syscall_nr_syslog                       = (__NR_SYSCALL_BASE + 103);
+syscall_nr_setitimer                    = (__NR_SYSCALL_BASE + 104);
+syscall_nr_getitimer                    = (__NR_SYSCALL_BASE + 105);
+syscall_nr_wait4                        = (__NR_SYSCALL_BASE + 114);
+syscall_nr_sysinfo                      = (__NR_SYSCALL_BASE + 116);
+syscall_nr_fsync                        = (__NR_SYSCALL_BASE + 118);
+syscall_nr_clone                        = (__NR_SYSCALL_BASE + 120);
+syscall_nr_uname                        = (__NR_SYSCALL_BASE + 122);
+syscall_nr_mprotect                     = (__NR_SYSCALL_BASE + 125);
+syscall_nr_sigprocmask                  = (__NR_SYSCALL_BASE + 126);
+syscall_nr_init_module                  = (__NR_SYSCALL_BASE + 128);
+syscall_nr_delete_module                = (__NR_SYSCALL_BASE + 129);
+syscall_nr_getpgid                      = (__NR_SYSCALL_BASE + 132);
+syscall_nr_fchdir                       = (__NR_SYSCALL_BASE + 133);
+syscall_nr_personality                  = (__NR_SYSCALL_BASE + 136);
+syscall_nr__llseek                      = (__NR_SYSCALL_BASE + 140);
+syscall_nr__newselect                   = (__NR_SYSCALL_BASE + 142);
+syscall_nr_flock                        = (__NR_SYSCALL_BASE + 143);
+syscall_nr_msync                        = (__NR_SYSCALL_BASE + 144);
+syscall_nr_readv                        = (__NR_SYSCALL_BASE + 145);
+syscall_nr_writev                       = (__NR_SYSCALL_BASE + 146);
+syscall_nr_perf_event_open              = (__NR_SYSCALL_BASE + 364);
+
+syscall_nr_kill                         = (__NR_SYSCALL_BASE + 37);
+syscall_nr_exit_group                   = (__NR_SYSCALL_BASE + 248);
+syscall_nr_waitid                       = (__NR_SYSCALL_BASE + 280);
+syscall_nr_setuid32                     = (__NR_SYSCALL_BASE + 213);
+syscall_nr_getuid32                     = (__NR_SYSCALL_BASE + 199);
+syscall_nr_getgid32                     = (__NR_SYSCALL_BASE + 200);
+syscall_nr_geteuid32                    = (__NR_SYSCALL_BASE + 201);
+syscall_nr_getegid32                    = (__NR_SYSCALL_BASE + 202);
+syscall_nr_getresuid32                  = (__NR_SYSCALL_BASE + 209);
+syscall_nr_getresgid32                  = (__NR_SYSCALL_BASE + 211);
+syscall_nr_gettid                       = (__NR_SYSCALL_BASE + 224);
+syscall_nr_readahead                    = (__NR_SYSCALL_BASE + 225);
+syscall_nr_getgroups32                  = (__NR_SYSCALL_BASE + 205);
+syscall_nr_setgid32                     = (__NR_SYSCALL_BASE + 214);
+syscall_nr_setreuid32                   = (__NR_SYSCALL_BASE + 203);
+syscall_nr_setresuid32                  = (__NR_SYSCALL_BASE + 208);
+syscall_nr_setresgid32                  = (__NR_SYSCALL_BASE + 210);
+syscall_nr_ugetrlimit                   = (__NR_SYSCALL_BASE + 191);
+syscall_nr_setgroups32                  = (__NR_SYSCALL_BASE + 206);
+syscall_nr_vfork                        = (__NR_SYSCALL_BASE + 190);
+syscall_nr_setregid32                   = (__NR_SYSCALL_BASE + 204);
+syscall_nr_prctl                        = (__NR_SYSCALL_BASE + 172);
+syscall_nr_capget                       = (__NR_SYSCALL_BASE + 184);
+syscall_nr_capset                       = (__NR_SYSCALL_BASE + 185);
+syscall_nr_sigaltstack                  = (__NR_SYSCALL_BASE + 186);
+syscall_nr_pread64                      = (__NR_SYSCALL_BASE + 180);
+syscall_nr_pwrite64                     = (__NR_SYSCALL_BASE + 181);
+syscall_nr_openat                       = (__NR_SYSCALL_BASE + 322);
+syscall_nr_mmap2                        = (__NR_SYSCALL_BASE + 192);
+syscall_nr_mremap                       = (__NR_SYSCALL_BASE + 163);
+syscall_nr_madvise                      = (__NR_SYSCALL_BASE + 220);
+syscall_nr_mlock                        = (__NR_SYSCALL_BASE + 150);
+syscall_nr_munlock                      = (__NR_SYSCALL_BASE + 151);
+syscall_nr_mincore                      = (__NR_SYSCALL_BASE + 219);
+syscall_nr_pipe                         = (__NR_SYSCALL_BASE + 42);
+syscall_nr_pipe2                        = (__NR_SYSCALL_BASE + 359);
+syscall_nr_ftruncate64                  = (__NR_SYSCALL_BASE + 194);
+syscall_nr_getdents64                   = (__NR_SYSCALL_BASE + 217);
+syscall_nr_fdatasync                    = (__NR_SYSCALL_BASE + 148);
+syscall_nr_fchown32                     = (__NR_SYSCALL_BASE + 207);
+syscall_nr_fcntl64                      = (__NR_SYSCALL_BASE + 221);
+syscall_nr_fstatfs64                    = (__NR_SYSCALL_BASE + 267);
+syscall_nr_sendfile                     = (__NR_SYSCALL_BASE + 187);
+syscall_nr_fstatat64                    = (__NR_SYSCALL_BASE + 327);
+syscall_nr_mkdirat                      = (__NR_SYSCALL_BASE + 323);
+syscall_nr_fchownat                     = (__NR_SYSCALL_BASE + 325);
+syscall_nr_fchmodat                     = (__NR_SYSCALL_BASE + 333);
+syscall_nr_renameat                     = (__NR_SYSCALL_BASE + 329);
+syscall_nr_fsetxattr                    = (__NR_SYSCALL_BASE + 228);
+syscall_nr_fgetxattr                    = (__NR_SYSCALL_BASE + 231);
+syscall_nr_flistxattr                   = (__NR_SYSCALL_BASE + 234);
+syscall_nr_fremovexattr                 = (__NR_SYSCALL_BASE + 237);
+syscall_nr_unlinkat                     = (__NR_SYSCALL_BASE + 328);
+syscall_nr_chown32                      = (__NR_SYSCALL_BASE + 212);
+syscall_nr_lchown32                     = (__NR_SYSCALL_BASE + 198);
+syscall_nr_fstat64                      = (__NR_SYSCALL_BASE + 197);
+syscall_nr_stat64                       = (__NR_SYSCALL_BASE + 195);
+syscall_nr_lstat64                      = (__NR_SYSCALL_BASE + 196);
+syscall_nr_getcwd                       = (__NR_SYSCALL_BASE + 183);
+syscall_nr_faccessat                    = (__NR_SYSCALL_BASE + 334);
+syscall_nr_setxattr                     = (__NR_SYSCALL_BASE + 226);
+syscall_nr_lsetxattr                    = (__NR_SYSCALL_BASE + 227);
+syscall_nr_getxattr                     = (__NR_SYSCALL_BASE + 229);
+syscall_nr_lgetxattr                    = (__NR_SYSCALL_BASE + 230);
+syscall_nr_listxattr                    = (__NR_SYSCALL_BASE + 232);
+syscall_nr_llistxattr                   = (__NR_SYSCALL_BASE + 233);
+syscall_nr_removexattr                  = (__NR_SYSCALL_BASE + 235);
+syscall_nr_lremovexattr                 = (__NR_SYSCALL_BASE + 236);
+syscall_nr_statfs64                     = (__NR_SYSCALL_BASE + 266);
+syscall_nr_unshare                      = (__NR_SYSCALL_BASE + 337);
+syscall_nr_nanosleep                    = (__NR_SYSCALL_BASE + 162);
+syscall_nr_clock_gettime                = (__NR_SYSCALL_BASE + 263);
+syscall_nr_clock_settime                = (__NR_SYSCALL_BASE + 262);
+syscall_nr_clock_getres                 = (__NR_SYSCALL_BASE + 264);
+syscall_nr_clock_nanosleep              = (__NR_SYSCALL_BASE + 265);
+syscall_nr_timer_create                 = (__NR_SYSCALL_BASE + 257);
+syscall_nr_timer_settime                = (__NR_SYSCALL_BASE + 258);
+syscall_nr_timer_gettime                = (__NR_SYSCALL_BASE + 259);
+syscall_nr_timer_getoverrun             = (__NR_SYSCALL_BASE + 260);
+syscall_nr_timer_delete                 = (__NR_SYSCALL_BASE + 261);
+syscall_nr_utimes                       = (__NR_SYSCALL_BASE + 269);
+syscall_nr_utimensat                    = (__NR_SYSCALL_BASE + 348);
+syscall_nr_sigsuspend                   = (__NR_SYSCALL_BASE + 72);
+syscall_nr_rt_sigaction                 = (__NR_SYSCALL_BASE + 174);
+syscall_nr_rt_sigprocmask               = (__NR_SYSCALL_BASE + 175);
+syscall_nr_rt_sigtimedwait              = (__NR_SYSCALL_BASE + 177);
+syscall_nr_socket                       = (__NR_SYSCALL_BASE + 281);
+syscall_nr_socketpair                   = (__NR_SYSCALL_BASE + 288);
+syscall_nr_bind                         = (__NR_SYSCALL_BASE + 282);
+syscall_nr_connect                      = (__NR_SYSCALL_BASE + 283);
+syscall_nr_listen                       = (__NR_SYSCALL_BASE + 284);
+syscall_nr_accept                       = (__NR_SYSCALL_BASE + 285);
+syscall_nr_getsockname                  = (__NR_SYSCALL_BASE + 286);
+syscall_nr_getpeername                  = (__NR_SYSCALL_BASE + 287);
+syscall_nr_sendto                       = (__NR_SYSCALL_BASE + 290);
+syscall_nr_recvfrom                     = (__NR_SYSCALL_BASE + 292);
+syscall_nr_shutdown                     = (__NR_SYSCALL_BASE + 293);
+syscall_nr_setsockopt                   = (__NR_SYSCALL_BASE + 294);
+syscall_nr_getsockopt                   = (__NR_SYSCALL_BASE + 295);
+syscall_nr_sendmsg                      = (__NR_SYSCALL_BASE + 296);
+syscall_nr_recvmsg                      = (__NR_SYSCALL_BASE + 297);
+syscall_nr_sched_setscheduler           = (__NR_SYSCALL_BASE + 156);
+syscall_nr_sched_getscheduler           = (__NR_SYSCALL_BASE + 157);
+syscall_nr_sched_yield                  = (__NR_SYSCALL_BASE + 158);
+syscall_nr_sched_setparam               = (__NR_SYSCALL_BASE + 154);
+syscall_nr_sched_getparam               = (__NR_SYSCALL_BASE + 155);
+syscall_nr_sched_get_priority_max       = (__NR_SYSCALL_BASE + 159);
+syscall_nr_sched_get_priority_min       = (__NR_SYSCALL_BASE + 160);
+syscall_nr_sched_rr_get_interval        = (__NR_SYSCALL_BASE + 161);
+syscall_nr_sched_setaffinity            = (__NR_SYSCALL_BASE + 241);
+syscall_nr_sched_getaffinity            = (__NR_SYSCALL_BASE + 242);
+syscall_nr_getcpu                       = (__NR_SYSCALL_BASE + 345);
+syscall_nr_ioprio_set                   = (__NR_SYSCALL_BASE + 314);
+syscall_nr_ioprio_get                   = (__NR_SYSCALL_BASE + 315);
+syscall_nr_futex                        = (__NR_SYSCALL_BASE + 240);
+syscall_nr_epoll_create                 = (__NR_SYSCALL_BASE + 250);
+syscall_nr_epoll_ctl                    = (__NR_SYSCALL_BASE + 251);
+syscall_nr_epoll_wait                   = (__NR_SYSCALL_BASE + 252);
+syscall_nr_inotify_init                 = (__NR_SYSCALL_BASE + 316);
+syscall_nr_inotify_add_watch            = (__NR_SYSCALL_BASE + 317);
+syscall_nr_inotify_rm_watch             = (__NR_SYSCALL_BASE + 318);
+syscall_nr_poll                         = (__NR_SYSCALL_BASE + 168);
+syscall_nr_eventfd2                     = (__NR_SYSCALL_BASE + 356);
+syscall_nr_ARM_set_tls                  = (__NR_SYSCALL_BASE + 983045);
+syscall_nr_ARM_cacheflush               = (__NR_SYSCALL_BASE + 983042);

rtl/android/i386/sysnr.inc

@@ -0,0 +1,204 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2017 by Yuriy Sydorov,
+    member of the Free Pascal development team.
+
+    Syscall nrs for i386-android
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+const
+  __NR_SYSCALL_BASE = 0;
+
+syscall_nr_exit                         = (__NR_SYSCALL_BASE + 1);
+syscall_nr_fork                         = (__NR_SYSCALL_BASE + 2);
+syscall_nr_read                         = (__NR_SYSCALL_BASE + 3);
+syscall_nr_write                        = (__NR_SYSCALL_BASE + 4);
+syscall_nr_open                         = (__NR_SYSCALL_BASE + 5);
+syscall_nr_close                        = (__NR_SYSCALL_BASE + 6);
+syscall_nr_link                         = (__NR_SYSCALL_BASE + 9);
+syscall_nr_unlink                       = (__NR_SYSCALL_BASE + 10);
+syscall_nr_execve                       = (__NR_SYSCALL_BASE + 11);
+syscall_nr_chdir                        = (__NR_SYSCALL_BASE + 12);
+syscall_nr_mknod                        = (__NR_SYSCALL_BASE + 14);
+syscall_nr_chmod                        = (__NR_SYSCALL_BASE + 15);
+syscall_nr_lseek                        = (__NR_SYSCALL_BASE + 19);
+syscall_nr_getpid                       = (__NR_SYSCALL_BASE + 20);
+syscall_nr_mount                        = (__NR_SYSCALL_BASE + 21);
+syscall_nr_ptrace                       = (__NR_SYSCALL_BASE + 26);
+syscall_nr_pause                        = (__NR_SYSCALL_BASE + 29);
+syscall_nr_access                       = (__NR_SYSCALL_BASE + 33);
+syscall_nr_sync                         = (__NR_SYSCALL_BASE + 36);
+syscall_nr_rename                       = (__NR_SYSCALL_BASE + 38);
+syscall_nr_mkdir                        = (__NR_SYSCALL_BASE + 39);
+syscall_nr_rmdir                        = (__NR_SYSCALL_BASE + 40);
+syscall_nr_dup                          = (__NR_SYSCALL_BASE + 41);
+syscall_nr_times                        = (__NR_SYSCALL_BASE + 43);
+syscall_nr_brk                          = (__NR_SYSCALL_BASE + 45);
+syscall_nr_acct                         = (__NR_SYSCALL_BASE + 51);
+syscall_nr_umount2                      = (__NR_SYSCALL_BASE + 52);
+syscall_nr_ioctl                        = (__NR_SYSCALL_BASE + 54);
+syscall_nr_fcntl                        = (__NR_SYSCALL_BASE + 55);
+syscall_nr_setpgid                      = (__NR_SYSCALL_BASE + 57);
+syscall_nr_umask                        = (__NR_SYSCALL_BASE + 60);
+syscall_nr_chroot                       = (__NR_SYSCALL_BASE + 61);
+syscall_nr_dup2                         = (__NR_SYSCALL_BASE + 63);
+syscall_nr_getppid                      = (__NR_SYSCALL_BASE + 64);
+syscall_nr_setsid                       = (__NR_SYSCALL_BASE + 66);
+syscall_nr_sigaction                    = (__NR_SYSCALL_BASE + 67);
+syscall_nr_sigpending                   = (__NR_SYSCALL_BASE + 73);
+syscall_nr_setrlimit                    = (__NR_SYSCALL_BASE + 75);
+syscall_nr_getrusage                    = (__NR_SYSCALL_BASE + 77);
+syscall_nr_gettimeofday                 = (__NR_SYSCALL_BASE + 78);
+syscall_nr_settimeofday                 = (__NR_SYSCALL_BASE + 79);
+syscall_nr_symlink                      = (__NR_SYSCALL_BASE + 83);
+syscall_nr_readlink                     = (__NR_SYSCALL_BASE + 85);
+syscall_nr_reboot                       = (__NR_SYSCALL_BASE + 88);
+syscall_nr_munmap                       = (__NR_SYSCALL_BASE + 91);
+syscall_nr_truncate                     = (__NR_SYSCALL_BASE + 92);
+syscall_nr_ftruncate                    = (__NR_SYSCALL_BASE + 93);
+syscall_nr_fchmod                       = (__NR_SYSCALL_BASE + 94);
+syscall_nr_getpriority                  = (__NR_SYSCALL_BASE + 96);
+syscall_nr_setpriority                  = (__NR_SYSCALL_BASE + 97);
+syscall_nr_syslog                       = (__NR_SYSCALL_BASE + 103);
+syscall_nr_setitimer                    = (__NR_SYSCALL_BASE + 104);
+syscall_nr_getitimer                    = (__NR_SYSCALL_BASE + 105);
+syscall_nr_wait4                        = (__NR_SYSCALL_BASE + 114);
+syscall_nr_sysinfo                      = (__NR_SYSCALL_BASE + 116);
+syscall_nr_fsync                        = (__NR_SYSCALL_BASE + 118);
+syscall_nr_clone                        = (__NR_SYSCALL_BASE + 120);
+syscall_nr_uname                        = (__NR_SYSCALL_BASE + 122);
+syscall_nr_mprotect                     = (__NR_SYSCALL_BASE + 125);
+syscall_nr_sigprocmask                  = (__NR_SYSCALL_BASE + 126);
+syscall_nr_init_module                  = (__NR_SYSCALL_BASE + 128);
+syscall_nr_delete_module                = (__NR_SYSCALL_BASE + 129);
+syscall_nr_getpgid                      = (__NR_SYSCALL_BASE + 132);
+syscall_nr_fchdir                       = (__NR_SYSCALL_BASE + 133);
+syscall_nr_personality                  = (__NR_SYSCALL_BASE + 136);
+syscall_nr__llseek                      = (__NR_SYSCALL_BASE + 140);
+syscall_nr__newselect                   = (__NR_SYSCALL_BASE + 142);
+syscall_nr_flock                        = (__NR_SYSCALL_BASE + 143);
+syscall_nr_msync                        = (__NR_SYSCALL_BASE + 144);
+syscall_nr_readv                        = (__NR_SYSCALL_BASE + 145);
+syscall_nr_writev                       = (__NR_SYSCALL_BASE + 146);
+syscall_nr_perf_event_open              = (__NR_SYSCALL_BASE + 364);
+
+syscall_nr_waitpid                      = (__NR_SYSCALL_BASE + 7);
+syscall_nr_kill                         = (__NR_SYSCALL_BASE + 37);
+syscall_nr_pipe                         = (__NR_SYSCALL_BASE + 42);
+syscall_nr_sigsuspend                   = (__NR_SYSCALL_BASE + 72);
+syscall_nr_socketcall                   = (__NR_SYSCALL_BASE + 102);
+syscall_nr_fdatasync                    = (__NR_SYSCALL_BASE + 148);
+syscall_nr_mlock                        = (__NR_SYSCALL_BASE + 150);
+syscall_nr_munlock                      = (__NR_SYSCALL_BASE + 151);
+syscall_nr_sched_setparam               = (__NR_SYSCALL_BASE + 154);
+syscall_nr_sched_getparam               = (__NR_SYSCALL_BASE + 155);
+syscall_nr_sched_setscheduler           = (__NR_SYSCALL_BASE + 156);
+syscall_nr_sched_getscheduler           = (__NR_SYSCALL_BASE + 157);
+syscall_nr_sched_yield                  = (__NR_SYSCALL_BASE + 158);
+syscall_nr_sched_get_priority_max       = (__NR_SYSCALL_BASE + 159);
+syscall_nr_sched_get_priority_min       = (__NR_SYSCALL_BASE + 160);
+syscall_nr_sched_rr_get_interval        = (__NR_SYSCALL_BASE + 161);
+syscall_nr_nanosleep                    = (__NR_SYSCALL_BASE + 162);
+syscall_nr_mremap                       = (__NR_SYSCALL_BASE + 163);
+syscall_nr_poll                         = (__NR_SYSCALL_BASE + 168);
+syscall_nr_prctl                        = (__NR_SYSCALL_BASE + 172);
+syscall_nr_rt_sigaction                 = (__NR_SYSCALL_BASE + 174);
+syscall_nr_rt_sigprocmask               = (__NR_SYSCALL_BASE + 175);
+syscall_nr_rt_sigtimedwait              = (__NR_SYSCALL_BASE + 177);
+syscall_nr_pread64                      = (__NR_SYSCALL_BASE + 180);
+syscall_nr_pwrite64                     = (__NR_SYSCALL_BASE + 181);
+syscall_nr_getcwd                       = (__NR_SYSCALL_BASE + 183);
+syscall_nr_capget                       = (__NR_SYSCALL_BASE + 184);
+syscall_nr_capset                       = (__NR_SYSCALL_BASE + 185);
+syscall_nr_sigaltstack                  = (__NR_SYSCALL_BASE + 186);
+syscall_nr_sendfile                     = (__NR_SYSCALL_BASE + 187);
+syscall_nr_ugetrlimit                   = (__NR_SYSCALL_BASE + 191);
+syscall_nr_mmap2                        = (__NR_SYSCALL_BASE + 192);
+syscall_nr_ftruncate64                  = (__NR_SYSCALL_BASE + 194);
+syscall_nr_stat64                       = (__NR_SYSCALL_BASE + 195);
+syscall_nr_lstat64                      = (__NR_SYSCALL_BASE + 196);
+syscall_nr_fstat64                      = (__NR_SYSCALL_BASE + 197);
+syscall_nr_lchown32                     = (__NR_SYSCALL_BASE + 198);
+syscall_nr_getuid32                     = (__NR_SYSCALL_BASE + 199);
+syscall_nr_getgid32                     = (__NR_SYSCALL_BASE + 200);
+syscall_nr_geteuid32                    = (__NR_SYSCALL_BASE + 201);
+syscall_nr_getegid32                    = (__NR_SYSCALL_BASE + 202);
+syscall_nr_setreuid32                   = (__NR_SYSCALL_BASE + 203);
+syscall_nr_setregid32                   = (__NR_SYSCALL_BASE + 204);
+syscall_nr_getgroups32                  = (__NR_SYSCALL_BASE + 205);
+syscall_nr_setgroups32                  = (__NR_SYSCALL_BASE + 206);
+syscall_nr_fchown32                     = (__NR_SYSCALL_BASE + 207);
+syscall_nr_setresuid32                  = (__NR_SYSCALL_BASE + 208);
+syscall_nr_getresuid32                  = (__NR_SYSCALL_BASE + 209);
+syscall_nr_setresgid32                  = (__NR_SYSCALL_BASE + 210);
+syscall_nr_getresgid32                  = (__NR_SYSCALL_BASE + 211);
+syscall_nr_chown32                      = (__NR_SYSCALL_BASE + 212);
+syscall_nr_setuid32                     = (__NR_SYSCALL_BASE + 213);
+syscall_nr_setgid32                     = (__NR_SYSCALL_BASE + 214);
+syscall_nr_mincore                      = (__NR_SYSCALL_BASE + 218);
+syscall_nr_madvise                      = (__NR_SYSCALL_BASE + 219);
+syscall_nr_getdents64                   = (__NR_SYSCALL_BASE + 220);
+syscall_nr_fcntl64                      = (__NR_SYSCALL_BASE + 221);
+syscall_nr_gettid                       = (__NR_SYSCALL_BASE + 224);
+syscall_nr_readahead                    = (__NR_SYSCALL_BASE + 225);
+syscall_nr_setxattr                     = (__NR_SYSCALL_BASE + 226);
+syscall_nr_lsetxattr                    = (__NR_SYSCALL_BASE + 227);
+syscall_nr_fsetxattr                    = (__NR_SYSCALL_BASE + 228);
+syscall_nr_getxattr                     = (__NR_SYSCALL_BASE + 229);
+syscall_nr_lgetxattr                    = (__NR_SYSCALL_BASE + 230);
+syscall_nr_fgetxattr                    = (__NR_SYSCALL_BASE + 231);
+syscall_nr_listxattr                    = (__NR_SYSCALL_BASE + 232);
+syscall_nr_llistxattr                   = (__NR_SYSCALL_BASE + 233);
+syscall_nr_flistxattr                   = (__NR_SYSCALL_BASE + 234);
+syscall_nr_removexattr                  = (__NR_SYSCALL_BASE + 235);
+syscall_nr_lremovexattr                 = (__NR_SYSCALL_BASE + 236);
+syscall_nr_fremovexattr                 = (__NR_SYSCALL_BASE + 237);
+syscall_nr_tkill                        = (__NR_SYSCALL_BASE + 238);
+syscall_nr_futex                        = (__NR_SYSCALL_BASE + 240);
+syscall_nr_sched_setaffinity            = (__NR_SYSCALL_BASE + 241);
+syscall_nr_sched_getaffinity            = (__NR_SYSCALL_BASE + 242);
+syscall_nr_set_thread_area              = (__NR_SYSCALL_BASE + 243);
+syscall_nr_exit_group                   = (__NR_SYSCALL_BASE + 252);
+syscall_nr_epoll_create                 = (__NR_SYSCALL_BASE + 254);
+syscall_nr_epoll_ctl                    = (__NR_SYSCALL_BASE + 255);
+syscall_nr_epoll_wait                   = (__NR_SYSCALL_BASE + 256);
+syscall_nr_timer_create                 = (__NR_SYSCALL_BASE + 259);
+syscall_nr_timer_settime                = (__NR_SYSCALL_BASE + 260);
+syscall_nr_timer_gettime                = (__NR_SYSCALL_BASE + 261);
+syscall_nr_timer_getoverrun             = (__NR_SYSCALL_BASE + 262);
+syscall_nr_timer_delete                 = (__NR_SYSCALL_BASE + 263);
+syscall_nr_clock_settime                = (__NR_SYSCALL_BASE + 264);
+syscall_nr_clock_gettime                = (__NR_SYSCALL_BASE + 265);
+syscall_nr_clock_getres                 = (__NR_SYSCALL_BASE + 266);
+syscall_nr_clock_nanosleep              = (__NR_SYSCALL_BASE + 267);
+syscall_nr_statfs64                     = (__NR_SYSCALL_BASE + 268);
+syscall_nr_fstatfs64                    = (__NR_SYSCALL_BASE + 269);
+syscall_nr_tgkill                       = (__NR_SYSCALL_BASE + 270);
+syscall_nr_utimes                       = (__NR_SYSCALL_BASE + 271);
+syscall_nr_waitid                       = (__NR_SYSCALL_BASE + 284);
+syscall_nr_ioprio_set                   = (__NR_SYSCALL_BASE + 289);
+syscall_nr_ioprio_get                   = (__NR_SYSCALL_BASE + 290);
+syscall_nr_inotify_init                 = (__NR_SYSCALL_BASE + 291);
+syscall_nr_inotify_add_watch            = (__NR_SYSCALL_BASE + 292);
+syscall_nr_inotify_rm_watch             = (__NR_SYSCALL_BASE + 293);
+syscall_nr_openat                       = (__NR_SYSCALL_BASE + 295);
+syscall_nr_mkdirat                      = (__NR_SYSCALL_BASE + 296);
+syscall_nr_fchownat                     = (__NR_SYSCALL_BASE + 298);
+syscall_nr_fstatat64                    = (__NR_SYSCALL_BASE + 300);
+syscall_nr_unlinkat                     = (__NR_SYSCALL_BASE + 301);
+syscall_nr_renameat                     = (__NR_SYSCALL_BASE + 302);
+syscall_nr_fchmodat                     = (__NR_SYSCALL_BASE + 306);
+syscall_nr_faccessat                    = (__NR_SYSCALL_BASE + 307);
+syscall_nr_unshare                      = (__NR_SYSCALL_BASE + 310);
+syscall_nr_getcpu                       = (__NR_SYSCALL_BASE + 318);
+syscall_nr_utimensat                    = (__NR_SYSCALL_BASE + 320);
+syscall_nr_eventfd2                     = (__NR_SYSCALL_BASE + 328);
+syscall_nr_pipe2                        = (__NR_SYSCALL_BASE + 331);

rtl/android/mipsel/sysnr.inc

@@ -0,0 +1,220 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2017 by Yuriy Sydorov,
+    member of the Free Pascal development team.
+
+    Syscall nrs for mipsel-android
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+const
+  __NR_SYSCALL_BASE = 4000;
+
+syscall_nr_exit                         = (__NR_SYSCALL_BASE + 1);
+syscall_nr_fork                         = (__NR_SYSCALL_BASE + 2);
+syscall_nr_read                         = (__NR_SYSCALL_BASE + 3);
+syscall_nr_write                        = (__NR_SYSCALL_BASE + 4);
+syscall_nr_open                         = (__NR_SYSCALL_BASE + 5);
+syscall_nr_close                        = (__NR_SYSCALL_BASE + 6);
+syscall_nr_link                         = (__NR_SYSCALL_BASE + 9);
+syscall_nr_unlink                       = (__NR_SYSCALL_BASE + 10);
+syscall_nr_execve                       = (__NR_SYSCALL_BASE + 11);
+syscall_nr_chdir                        = (__NR_SYSCALL_BASE + 12);
+syscall_nr_mknod                        = (__NR_SYSCALL_BASE + 14);
+syscall_nr_chmod                        = (__NR_SYSCALL_BASE + 15);
+syscall_nr_lseek                        = (__NR_SYSCALL_BASE + 19);
+syscall_nr_getpid                       = (__NR_SYSCALL_BASE + 20);
+syscall_nr_mount                        = (__NR_SYSCALL_BASE + 21);
+syscall_nr_ptrace                       = (__NR_SYSCALL_BASE + 26);
+syscall_nr_pause                        = (__NR_SYSCALL_BASE + 29);
+syscall_nr_access                       = (__NR_SYSCALL_BASE + 33);
+syscall_nr_sync                         = (__NR_SYSCALL_BASE + 36);
+syscall_nr_rename                       = (__NR_SYSCALL_BASE + 38);
+syscall_nr_mkdir                        = (__NR_SYSCALL_BASE + 39);
+syscall_nr_rmdir                        = (__NR_SYSCALL_BASE + 40);
+syscall_nr_dup                          = (__NR_SYSCALL_BASE + 41);
+syscall_nr_times                        = (__NR_SYSCALL_BASE + 43);
+syscall_nr_brk                          = (__NR_SYSCALL_BASE + 45);
+syscall_nr_acct                         = (__NR_SYSCALL_BASE + 51);
+syscall_nr_umount2                      = (__NR_SYSCALL_BASE + 52);
+syscall_nr_ioctl                        = (__NR_SYSCALL_BASE + 54);
+syscall_nr_fcntl                        = (__NR_SYSCALL_BASE + 55);
+syscall_nr_setpgid                      = (__NR_SYSCALL_BASE + 57);
+syscall_nr_umask                        = (__NR_SYSCALL_BASE + 60);
+syscall_nr_chroot                       = (__NR_SYSCALL_BASE + 61);
+syscall_nr_dup2                         = (__NR_SYSCALL_BASE + 63);
+syscall_nr_getppid                      = (__NR_SYSCALL_BASE + 64);
+syscall_nr_setsid                       = (__NR_SYSCALL_BASE + 66);
+syscall_nr_sigaction                    = (__NR_SYSCALL_BASE + 67);
+syscall_nr_sigpending                   = (__NR_SYSCALL_BASE + 73);
+syscall_nr_setrlimit                    = (__NR_SYSCALL_BASE + 75);
+syscall_nr_getrusage                    = (__NR_SYSCALL_BASE + 77);
+syscall_nr_gettimeofday                 = (__NR_SYSCALL_BASE + 78);
+syscall_nr_settimeofday                 = (__NR_SYSCALL_BASE + 79);
+syscall_nr_symlink                      = (__NR_SYSCALL_BASE + 83);
+syscall_nr_readlink                     = (__NR_SYSCALL_BASE + 85);
+syscall_nr_reboot                       = (__NR_SYSCALL_BASE + 88);
+syscall_nr_munmap                       = (__NR_SYSCALL_BASE + 91);
+syscall_nr_truncate                     = (__NR_SYSCALL_BASE + 92);
+syscall_nr_ftruncate                    = (__NR_SYSCALL_BASE + 93);
+syscall_nr_fchmod                       = (__NR_SYSCALL_BASE + 94);
+syscall_nr_getpriority                  = (__NR_SYSCALL_BASE + 96);
+syscall_nr_setpriority                  = (__NR_SYSCALL_BASE + 97);
+syscall_nr_syslog                       = (__NR_SYSCALL_BASE + 103);
+syscall_nr_setitimer                    = (__NR_SYSCALL_BASE + 104);
+syscall_nr_getitimer                    = (__NR_SYSCALL_BASE + 105);
+syscall_nr_wait4                        = (__NR_SYSCALL_BASE + 114);
+syscall_nr_sysinfo                      = (__NR_SYSCALL_BASE + 116);
+syscall_nr_fsync                        = (__NR_SYSCALL_BASE + 118);
+syscall_nr_clone                        = (__NR_SYSCALL_BASE + 120);
+syscall_nr_uname                        = (__NR_SYSCALL_BASE + 122);
+syscall_nr_mprotect                     = (__NR_SYSCALL_BASE + 125);
+syscall_nr_sigprocmask                  = (__NR_SYSCALL_BASE + 126);
+syscall_nr_init_module                  = (__NR_SYSCALL_BASE + 128);
+syscall_nr_delete_module                = (__NR_SYSCALL_BASE + 129);
+syscall_nr_getpgid                      = (__NR_SYSCALL_BASE + 132);
+syscall_nr_fchdir                       = (__NR_SYSCALL_BASE + 133);
+syscall_nr_personality                  = (__NR_SYSCALL_BASE + 136);
+syscall_nr__llseek                      = (__NR_SYSCALL_BASE + 140);
+syscall_nr__newselect                   = (__NR_SYSCALL_BASE + 142);
+syscall_nr_flock                        = (__NR_SYSCALL_BASE + 143);
+syscall_nr_msync                        = (__NR_SYSCALL_BASE + 144);
+syscall_nr_readv                        = (__NR_SYSCALL_BASE + 145);
+syscall_nr_writev                       = (__NR_SYSCALL_BASE + 146);
+syscall_nr_perf_event_open              = (__NR_SYSCALL_BASE + 364);
+
+syscall_nr_syscall                      = (__NR_SYSCALL_BASE + 0);
+syscall_nr_waitpid                      = (__NR_SYSCALL_BASE + 7);
+syscall_nr_lchown                       = (__NR_SYSCALL_BASE + 16);
+syscall_nr_setuid                       = (__NR_SYSCALL_BASE + 23);
+syscall_nr_getuid                       = (__NR_SYSCALL_BASE + 24);
+syscall_nr_kill                         = (__NR_SYSCALL_BASE + 37);
+syscall_nr_setgid                       = (__NR_SYSCALL_BASE + 46);
+syscall_nr_getgid                       = (__NR_SYSCALL_BASE + 47);
+syscall_nr_geteuid                      = (__NR_SYSCALL_BASE + 49);
+syscall_nr_getegid                      = (__NR_SYSCALL_BASE + 50);
+syscall_nr_setreuid                     = (__NR_SYSCALL_BASE + 70);
+syscall_nr_setregid                     = (__NR_SYSCALL_BASE + 71);
+syscall_nr_sigsuspend                   = (__NR_SYSCALL_BASE + 72);
+syscall_nr_getrlimit                    = (__NR_SYSCALL_BASE + 76);
+syscall_nr_getgroups                    = (__NR_SYSCALL_BASE + 80);
+syscall_nr_setgroups                    = (__NR_SYSCALL_BASE + 81);
+syscall_nr_fchown                       = (__NR_SYSCALL_BASE + 95);
+syscall_nr_cacheflush                   = (__NR_SYSCALL_BASE + 147);
+syscall_nr_fdatasync                    = (__NR_SYSCALL_BASE + 152);
+syscall_nr_mlock                        = (__NR_SYSCALL_BASE + 154);
+syscall_nr_munlock                      = (__NR_SYSCALL_BASE + 155);
+syscall_nr_sched_setparam               = (__NR_SYSCALL_BASE + 158);
+syscall_nr_sched_getparam               = (__NR_SYSCALL_BASE + 159);
+syscall_nr_sched_setscheduler           = (__NR_SYSCALL_BASE + 160);
+syscall_nr_sched_getscheduler           = (__NR_SYSCALL_BASE + 161);
+syscall_nr_sched_yield                  = (__NR_SYSCALL_BASE + 162);
+syscall_nr_sched_get_priority_max       = (__NR_SYSCALL_BASE + 163);
+syscall_nr_sched_get_priority_min       = (__NR_SYSCALL_BASE + 164);
+syscall_nr_sched_rr_get_interval        = (__NR_SYSCALL_BASE + 165);
+syscall_nr_nanosleep                    = (__NR_SYSCALL_BASE + 166);
+syscall_nr_mremap                       = (__NR_SYSCALL_BASE + 167);
+syscall_nr_accept                       = (__NR_SYSCALL_BASE + 168);
+syscall_nr_bind                         = (__NR_SYSCALL_BASE + 169);
+syscall_nr_connect                      = (__NR_SYSCALL_BASE + 170);
+syscall_nr_getpeername                  = (__NR_SYSCALL_BASE + 171);
+syscall_nr_getsockname                  = (__NR_SYSCALL_BASE + 172);
+syscall_nr_getsockopt                   = (__NR_SYSCALL_BASE + 173);
+syscall_nr_listen                       = (__NR_SYSCALL_BASE + 174);
+syscall_nr_recvfrom                     = (__NR_SYSCALL_BASE + 176);
+syscall_nr_recvmsg                      = (__NR_SYSCALL_BASE + 177);
+syscall_nr_sendmsg                      = (__NR_SYSCALL_BASE + 179);
+syscall_nr_sendto                       = (__NR_SYSCALL_BASE + 180);
+syscall_nr_setsockopt                   = (__NR_SYSCALL_BASE + 181);
+syscall_nr_shutdown                     = (__NR_SYSCALL_BASE + 182);
+syscall_nr_socket                       = (__NR_SYSCALL_BASE + 183);
+syscall_nr_socketpair                   = (__NR_SYSCALL_BASE + 184);
+syscall_nr_setresuid                    = (__NR_SYSCALL_BASE + 185);
+syscall_nr_getresuid                    = (__NR_SYSCALL_BASE + 186);
+syscall_nr_poll                         = (__NR_SYSCALL_BASE + 188);
+syscall_nr_setresgid                    = (__NR_SYSCALL_BASE + 190);
+syscall_nr_getresgid                    = (__NR_SYSCALL_BASE + 191);
+syscall_nr_prctl                        = (__NR_SYSCALL_BASE + 192);
+syscall_nr_rt_sigaction                 = (__NR_SYSCALL_BASE + 194);
+syscall_nr_rt_sigprocmask               = (__NR_SYSCALL_BASE + 195);
+syscall_nr_rt_sigtimedwait              = (__NR_SYSCALL_BASE + 197);
+syscall_nr_pread64                      = (__NR_SYSCALL_BASE + 200);
+syscall_nr_pwrite64                     = (__NR_SYSCALL_BASE + 201);
+syscall_nr_chown                        = (__NR_SYSCALL_BASE + 202);
+syscall_nr_getcwd                       = (__NR_SYSCALL_BASE + 203);
+syscall_nr_capget                       = (__NR_SYSCALL_BASE + 204);
+syscall_nr_capset                       = (__NR_SYSCALL_BASE + 205);
+syscall_nr_sigaltstack                  = (__NR_SYSCALL_BASE + 206);
+syscall_nr_sendfile                     = (__NR_SYSCALL_BASE + 207);
+syscall_nr_mmap2                        = (__NR_SYSCALL_BASE + 210);
+syscall_nr_ftruncate64                  = (__NR_SYSCALL_BASE + 212);
+syscall_nr_stat64                       = (__NR_SYSCALL_BASE + 213);
+syscall_nr_lstat64                      = (__NR_SYSCALL_BASE + 214);
+syscall_nr_fstat64                      = (__NR_SYSCALL_BASE + 215);
+syscall_nr_mincore                      = (__NR_SYSCALL_BASE + 217);
+syscall_nr_madvise                      = (__NR_SYSCALL_BASE + 218);
+syscall_nr_getdents64                   = (__NR_SYSCALL_BASE + 219);
+syscall_nr_fcntl64                      = (__NR_SYSCALL_BASE + 220);
+syscall_nr_gettid                       = (__NR_SYSCALL_BASE + 222);
+syscall_nr_readahead                    = (__NR_SYSCALL_BASE + 223);
+syscall_nr_setxattr                     = (__NR_SYSCALL_BASE + 224);
+syscall_nr_lsetxattr                    = (__NR_SYSCALL_BASE + 225);
+syscall_nr_fsetxattr                    = (__NR_SYSCALL_BASE + 226);
+syscall_nr_getxattr                     = (__NR_SYSCALL_BASE + 227);
+syscall_nr_lgetxattr                    = (__NR_SYSCALL_BASE + 228);
+syscall_nr_fgetxattr                    = (__NR_SYSCALL_BASE + 229);
+syscall_nr_listxattr                    = (__NR_SYSCALL_BASE + 230);
+syscall_nr_llistxattr                   = (__NR_SYSCALL_BASE + 231);
+syscall_nr_flistxattr                   = (__NR_SYSCALL_BASE + 232);
+syscall_nr_removexattr                  = (__NR_SYSCALL_BASE + 233);
+syscall_nr_lremovexattr                 = (__NR_SYSCALL_BASE + 234);
+syscall_nr_fremovexattr                 = (__NR_SYSCALL_BASE + 235);
+syscall_nr_tkill                        = (__NR_SYSCALL_BASE + 236);
+syscall_nr_futex                        = (__NR_SYSCALL_BASE + 238);
+syscall_nr_sched_setaffinity            = (__NR_SYSCALL_BASE + 239);
+syscall_nr_sched_getaffinity            = (__NR_SYSCALL_BASE + 240);
+syscall_nr_exit_group                   = (__NR_SYSCALL_BASE + 246);
+syscall_nr_epoll_create                 = (__NR_SYSCALL_BASE + 248);
+syscall_nr_epoll_ctl                    = (__NR_SYSCALL_BASE + 249);
+syscall_nr_epoll_wait                   = (__NR_SYSCALL_BASE + 250);
+syscall_nr_statfs64                     = (__NR_SYSCALL_BASE + 255);
+syscall_nr_fstatfs64                    = (__NR_SYSCALL_BASE + 256);
+syscall_nr_timer_create                 = (__NR_SYSCALL_BASE + 257);
+syscall_nr_timer_settime                = (__NR_SYSCALL_BASE + 258);
+syscall_nr_timer_gettime                = (__NR_SYSCALL_BASE + 259);
+syscall_nr_timer_getoverrun             = (__NR_SYSCALL_BASE + 260);
+syscall_nr_timer_delete                 = (__NR_SYSCALL_BASE + 261);
+syscall_nr_clock_settime                = (__NR_SYSCALL_BASE + 262);
+syscall_nr_clock_gettime                = (__NR_SYSCALL_BASE + 263);
+syscall_nr_clock_getres                 = (__NR_SYSCALL_BASE + 264);
+syscall_nr_clock_nanosleep              = (__NR_SYSCALL_BASE + 265);
+syscall_nr_tgkill                       = (__NR_SYSCALL_BASE + 266);
+syscall_nr_utimes                       = (__NR_SYSCALL_BASE + 267);
+syscall_nr_waitid                       = (__NR_SYSCALL_BASE + 278);
+syscall_nr_set_thread_area              = (__NR_SYSCALL_BASE + 283);
+syscall_nr_inotify_init                 = (__NR_SYSCALL_BASE + 284);
+syscall_nr_inotify_add_watch            = (__NR_SYSCALL_BASE + 285);
+syscall_nr_inotify_rm_watch             = (__NR_SYSCALL_BASE + 286);
+syscall_nr_openat                       = (__NR_SYSCALL_BASE + 288);
+syscall_nr_mkdirat                      = (__NR_SYSCALL_BASE + 289);
+syscall_nr_fchownat                     = (__NR_SYSCALL_BASE + 291);
+syscall_nr_fstatat64                    = (__NR_SYSCALL_BASE + 293);
+syscall_nr_unlinkat                     = (__NR_SYSCALL_BASE + 294);
+syscall_nr_renameat                     = (__NR_SYSCALL_BASE + 295);
+syscall_nr_fchmodat                     = (__NR_SYSCALL_BASE + 299);
+syscall_nr_faccessat                    = (__NR_SYSCALL_BASE + 300);
+syscall_nr_unshare                      = (__NR_SYSCALL_BASE + 303);
+syscall_nr_getcpu                       = (__NR_SYSCALL_BASE + 312);
+syscall_nr_ioprio_set                   = (__NR_SYSCALL_BASE + 314);
+syscall_nr_ioprio_get                   = (__NR_SYSCALL_BASE + 315);
+syscall_nr_utimensat                    = (__NR_SYSCALL_BASE + 316);
+syscall_nr_eventfd2                     = (__NR_SYSCALL_BASE + 325);
+syscall_nr_pipe2                        = (__NR_SYSCALL_BASE + 328);
+syscall_nr_pipe                         = (__NR_SYSCALL_BASE + 42);

rtl/linux/bunxsysc.inc

@@ -15,6 +15,21 @@
 
  **********************************************************************}
 
+{$ifdef android}
+const
+  syscall_nr_pread = syscall_nr_pread64;
+  syscall_nr_pwrite = syscall_nr_pwrite64;
+{$ifndef cpumips}
+  syscall_nr_getuid = syscall_nr_getuid32;
+  syscall_nr_geteuid = syscall_nr_geteuid32;
+  syscall_nr_getgid = syscall_nr_getgid32;
+  syscall_nr_getegid = syscall_nr_getegid32;
+  syscall_nr_setuid = syscall_nr_setuid32;
+  syscall_nr_setgid = syscall_nr_setgid32;
+  syscall_nr_getgroups = syscall_nr_getgroups32;
+{$endif cpumips}
+{$endif android}
+
 Function fpKill(Pid:pid_t;Sig:cint):cint;
 {
   Send signal 'sig' to a process, or a group of processes.
@@ -37,7 +52,11 @@ Function fpSigPending(var nset: TSigSet):cint;
   signals is set in SSet
 }
 begin
+{$ifdef android}
+  fpsigpending:=do_syscall(syscall_nr_sigpending,TSysParam(@nset));
+{$else}
   fpsigpending:=do_syscall(syscall_nr_rt_sigpending,TSysParam(@nset));
+{$endif android}
 end;
 
 function fpsigsuspend(const sigmask:TSigSet):cint;
@@ -47,7 +66,11 @@ function fpsigsuspend(const sigmask:TSigSet):cint;
 }
 
 begin
+{$ifdef android}
+  fpsigsuspend:= do_syscall(syscall_nr_sigsuspend,TSysParam(@sigmask));
+{$else}
   fpsigsuspend:= do_syscall(syscall_nr_rt_sigsuspend,TSysParam(@sigmask),TSysParam(8));
+{$endif android}
 end;
 
 function fpsigtimedwait(const sigset:TSigSet;info:Psiginfo;timeout:Ptimespec):cint;
@@ -297,7 +320,7 @@ end;
 function fpgetpgrp : pid_t;
 
 begin
-{$if defined(generic_linux_syscalls)}
+{$if defined(generic_linux_syscalls) or defined(android)}
  fpgetpgrp:=do_syscall(syscall_nr_getpgid,0);
 {$else}
  fpgetpgrp:=do_syscall(syscall_nr_getpgrp);
@@ -313,7 +336,11 @@ end;
 function fpgetsid (pid:TPid): pid_t;
 
 begin
+{$ifdef android}
+ fpgetsid:=0;
+{$else}
  fpgetsid:=do_syscall(syscall_nr_getsid,pid);
+{$endif android}
 end;
 
 Function fpumask(cmask:mode_t):mode_t;
@@ -362,7 +389,7 @@ end;
 Function fpchown(path:pchar;owner:uid_t;group:gid_t):cint;
 
 begin
-{$if defined(generic_linux_syscalls)}
+{$if defined(generic_linux_syscalls) or defined(android)}
   fpChOwn:=do_syscall(syscall_nr_fchownat,AT_FDCWD,TSysParam(path),TSysParam(owner),TSysParam(group),0);
 {$else}
   fpChOwn:=do_syscall(syscall_nr_chown,TSysParam(path),TSysParam(owner),TSysParam(group));
@@ -542,12 +569,12 @@ function fpNice(N:cint):cint;
 Doesn't exist in BSD. Linux emu uses setpriority in a construct as below:
 }
 
-{$if defined(generic_linux_syscalls) or defined(cpux86_64)}
+{$if defined(generic_linux_syscalls) or defined(cpux86_64) or defined(android)}
 var
   oldprio : cint;
 {$endif}
 begin
-{$if defined(generic_linux_syscalls) or defined(cpux86_64)}
+{$if defined(generic_linux_syscalls) or defined(cpux86_64) or defined(android)}
   oldprio:=fpGetPriority(Prio_Process,0);
   fpNice:=fpSetPriority(Prio_Process,0,oldprio+N);
   if fpNice=0 then

rtl/linux/linux.pp

@@ -219,7 +219,7 @@ type
 function clone(func:TCloneFunc;sp:pointer;flags:longint;args:pointer):longint; {$ifdef FPC_USE_LIBC} cdecl; external name 'clone'; {$endif}
 {$endif}
 
-{$ifndef FPC_USE_LIBC}
+{$if not defined(FPC_USE_LIBC) and not defined(android)}
 {$if defined(cpui386) or defined(cpux86_64)}
 const
   MODIFY_LDT_CONTENTS_DATA       = 0;
@@ -335,6 +335,7 @@ const CAP_CHOWN            = 0;
 
 
 //***********************************************SPLICE from kernel 2.6.17+****************************************
+{$ifndef android}
 
 const
 {* Flags for SPLICE and VMSPLICE.  *}
@@ -356,7 +357,9 @@ function splice (fdin: cInt; offin: off64_t; fdout: cInt;
 function tee(fd_in: cInt; fd_out: cInt; len: size_t; flags: cuInt): cInt; {$ifdef FPC_USE_LIBC} cdecl; external name 'tee'; {$ENDIF}
 
 {$endif} // x86
+{$endif android}
 
+{$ifndef android}
 const
   { flags for sync_file_range }
   SYNC_FILE_RANGE_WAIT_BEFORE = 1;
@@ -364,6 +367,7 @@ const
   SYNC_FILE_RANGE_WAIT_AFTER  = 4;
 
 function sync_file_range(fd: cInt; offset, nbytes: off64_t; flags: cuInt): cInt; {$ifdef FPC_USE_LIBC} cdecl; external name 'sync_file_range'; {$ENDIF}
+{$endif android}
 function fdatasync (fd: cint): cint; {$ifdef FPC_USE_LIBC} cdecl; external name 'sync_file_range'; {$ENDIF}
 
 {$PACKRECORDS 1}
@@ -565,6 +569,7 @@ begin
   capset:=do_syscall(syscall_nr_capset,Tsysparam(header),Tsysparam(data));
 end;
 
+{$ifndef android}
 // TODO: update also on non x86!
 {$ifdef cpu86} // didn't update syscall_nr on others yet
 
@@ -609,6 +614,8 @@ begin
 {$endif}
 end;
 
+{$endif android}
+
 function fdatasync (fd: cint): cint;
 begin
   fdatasync:=do_SysCall(syscall_nr_fdatasync, fd);
@@ -677,7 +684,7 @@ end;
 *)
 {$endif} // non-libc
 
-{$ifndef FPC_USE_LIBC}
+{$if not defined(FPC_USE_LIBC) and not defined(android)}
 {$if defined(cpui386) or defined(cpux86_64)}
 { does not exist as a wrapper in glibc, and exists only for x86 }
 function modify_ldt(func:cint;p:pointer;bytecount:culong):cint;
@@ -743,6 +750,12 @@ begin
   clock_settime:=do_SysCall(syscall_nr_clock_settime,tsysparam(clk_id),tsysparam(tp));
 end;
 
+{$if defined(android) and not defined(cpumips)}
+const
+  syscall_nr_setregid = syscall_nr_setregid32;
+  syscall_nr_setreuid = syscall_nr_setreuid32;
+{$endif}
+
 function setregid(rgid,egid : uid_t): cint;
 
 begin

rtl/linux/osdefs.inc

@@ -94,3 +94,13 @@
   {$define FPC_USEGETTIMEOFDAY}
 {$endif cpusparc64}
 
+{$ifdef android}
+  {$undef usestime}
+  {$undef OLDMMAP}
+  {$define MMAP2}
+  {$define NO_SYSCALL_UTIME}
+  {$ifndef cpumips}
+    {$define NO_SYSCALL_GETRLIMIT}
+  {$endif}
+  {$define FPC_USEGETTIMEOFDAY}
+{$endif android}

rtl/linux/ossysc.inc

@@ -262,12 +262,14 @@ asm
 end;
 {$endif cpusparc or cpusparc64}
 
+{$ifndef android}
 {$if defined(cpui386) or defined(cpuarm) or defined(cpux86_64)}
   {$define NEED_USER_TRAMPOLINE}
 {$endif}
 {$if defined(cpui386) or defined(cpuarm)}
   {$define NEED_USER_TRAMPOLINE_RT_DIFFERENT}
 {$endif}
+{$endif android}
 
 {$ifdef NEED_USER_TRAMPOLINE}
 

rtl/linux/unxsysc.inc

@@ -20,13 +20,21 @@ end;
 
 Function  fpfStatFS (Fd: cint; Info:pstatfs):cint;
 begin
+{$ifdef android}
+  fpfstatfs:=-1;
+{$else}
   fpfstatfs:=do_SysCall(SysCall_nr_fstatfs,fd,TSysParam(info))
+{$endif android}
 end;
 
 Function  fpStatFS  (Path:pchar; Info:pstatfs):cint;
 
 begin
+{$ifdef android}
+  fpStatFS:=-1;
+{$else}
   fpstatfs:=do_SysCall(SysCall_nr_statfs,TSysParam(path),TSysParam(Info))
+{$endif android}
 end;
 
 Function  fpfsync (fd : cint) : cint;
@@ -35,6 +43,8 @@ begin
   fpfsync:=do_SysCall(syscall_nr_fsync, fd);
 end;
 
+{$ifndef android}
+
 {--------------------------------
       Port IO functions
 --------------------------------}
@@ -59,3 +69,4 @@ end;
 
 {$endif cpui386}
 
+{$endif android}