From owner-svn-src-head@freebsd.org Sun Sep 18 11:36:56 2016 Return-Path: Delivered-To: svn-src-head@mailman.ysv.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2001:1900:2254:206a::19:1]) by mailman.ysv.freebsd.org (Postfix) with ESMTP id 38CCBBDFA29; Sun, 18 Sep 2016 11:36:56 +0000 (UTC) (envelope-from ed@FreeBSD.org) Received: from repo.freebsd.org (repo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:0]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (Client did not present a certificate) by mx1.freebsd.org (Postfix) with ESMTPS id 0275B796; Sun, 18 Sep 2016 11:36:55 +0000 (UTC) (envelope-from ed@FreeBSD.org) Received: from repo.freebsd.org ([127.0.1.37]) by repo.freebsd.org (8.15.2/8.15.2) with ESMTP id u8IBatUA087254; Sun, 18 Sep 2016 11:36:55 GMT (envelope-from ed@FreeBSD.org) Received: (from ed@localhost) by repo.freebsd.org (8.15.2/8.15.2/Submit) id u8IBat4Y087251; Sun, 18 Sep 2016 11:36:55 GMT (envelope-from ed@FreeBSD.org) Message-Id: <201609181136.u8IBat4Y087251@repo.freebsd.org> X-Authentication-Warning: repo.freebsd.org: ed set sender to ed@FreeBSD.org using -f From: Ed Schouten Date: Sun, 18 Sep 2016 11:36:55 +0000 (UTC) To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r305928 - in head/sys: arm/cloudabi32 conf contrib/cloudabi X-SVN-Group: head MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: svn-src-head@freebsd.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: SVN commit messages for the src tree for head/-current List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 18 Sep 2016 11:36:56 -0000 Author: ed Date: Sun Sep 18 11:36:54 2016 New Revision: 305928 URL: https://svnweb.freebsd.org/changeset/base/305928 Log: Add very preliminary support for CloudABI for ARMv6. In order to make CloudABI work on ARMv6, start off by copying over the sysvec for ARM64 and adjust it to use 32-bit registers. Also add code for fetching arguments from the stack if needed, as there are fewer register than on ARM64. Also import the vDSO that is needed to invoke system calls. This vDSO uses the intra procedure call register (ip) to store the system call number. This is a bit simpler than what native FreeBSD does, as FreeBSD uses r7, while preserving the original r7 into ip. This sysvec seems to be complete enough to start CloudABI processes. These processes are capable of linking in the vDSO and are therefore capable of executing (most?) system calls successfully. Unfortunately, the biggest show stopper is still that TLS is completely broken: - The linker used by CloudABI, LLD, still has troubles with some of the relocations needed for TLS. See LLVM bug 30218 for more details. - Whereas FreeBSD uses the tpidruro register for TLS, for CloudABI I want to make use of tpidrurw, so that userspace can modify the base address directly. This is needed for efficient emulation. Unfortunately, this register doesn't seem to be preserved across context switches yet. Obtained from: https://github.com/NuxiNL/cloudabi (the vDSO) Added: head/sys/arm/cloudabi32/ head/sys/arm/cloudabi32/cloudabi32_sysvec.c - copied, changed from r305926, head/sys/arm64/cloudabi64/cloudabi64_sysvec.c head/sys/contrib/cloudabi/cloudabi_vdso_armv6.S (contents, props changed) Modified: head/sys/conf/files.arm Copied and modified: head/sys/arm/cloudabi32/cloudabi32_sysvec.c (from r305926, head/sys/arm64/cloudabi64/cloudabi64_sysvec.c) ============================================================================== --- head/sys/arm64/cloudabi64/cloudabi64_sysvec.c Sun Sep 18 08:19:33 2016 (r305926, copy source) +++ head/sys/arm/cloudabi32/cloudabi32_sysvec.c Sun Sep 18 11:36:54 2016 (r305928) @@ -1,5 +1,5 @@ /*- - * Copyright (c) 2015 Nuxi, https://nuxi.nl/ + * Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -41,14 +41,14 @@ __FBSDID("$FreeBSD$"); #include -#include -#include +#include +#include -extern const char *cloudabi64_syscallnames[]; -extern struct sysent cloudabi64_sysent[]; +extern const char *cloudabi32_syscallnames[]; +extern struct sysent cloudabi32_sysent[]; static void -cloudabi64_proc_setregs(struct thread *td, struct image_params *imgp, +cloudabi32_proc_setregs(struct thread *td, struct image_params *imgp, unsigned long stack) { struct trapframe *regs; @@ -57,66 +57,74 @@ cloudabi64_proc_setregs(struct thread *t /* * The stack now contains a pointer to the TCB and the auxiliary - * vector. Let x0 point to the auxiliary vector, and set - * tpidr_el0 to the TCB. + * vector. Let r0 point to the auxiliary vector, and set + * tpidrurw to the TCB. */ regs = td->td_frame; - regs->tf_x[0] = td->td_retval[0] = - stack + roundup(sizeof(cloudabi64_tcb_t), sizeof(register_t)); + regs->tf_r0 = td->td_retval[0] = + stack + roundup(sizeof(cloudabi32_tcb_t), sizeof(register_t)); (void)cpu_set_user_tls(td, (void *)stack); } static int -cloudabi64_fetch_syscall_args(struct thread *td, struct syscall_args *sa) +cloudabi32_fetch_syscall_args(struct thread *td, struct syscall_args *sa) { struct trapframe *frame = td->td_frame; - int i; + int error; /* Obtain system call number. */ - sa->code = frame->tf_x[8]; - if (sa->code >= CLOUDABI64_SYS_MAXSYSCALL) + sa->code = frame->tf_r12; + if (sa->code >= CLOUDABI32_SYS_MAXSYSCALL) return (ENOSYS); - sa->callp = &cloudabi64_sysent[sa->code]; + sa->callp = &cloudabi32_sysent[sa->code]; sa->narg = sa->callp->sy_narg; - /* Fetch system call arguments. */ - for (i = 0; i < MAXARGS; i++) - sa->args[i] = frame->tf_x[i]; + /* Fetch system call arguments from registers and the stack. */ + sa->args[0] = frame->tf_r0; + sa->args[1] = frame->tf_r1; + sa->args[2] = frame->tf_r2; + sa->args[3] = frame->tf_r3; + if (sa->narg > 4) { + error = copyin((void *)td->td_frame->tf_usr_sp, &sa->args[4], + (sa->narg - 4) * sizeof(register_t)); + if (error != 0) + return (error); + } /* Default system call return values. */ td->td_retval[0] = 0; - td->td_retval[1] = frame->tf_x[1]; + td->td_retval[1] = frame->tf_r1; return (0); } static void -cloudabi64_set_syscall_retval(struct thread *td, int error) +cloudabi32_set_syscall_retval(struct thread *td, int error) { struct trapframe *frame = td->td_frame; switch (error) { case 0: /* System call succeeded. */ - frame->tf_x[0] = td->td_retval[0]; - frame->tf_x[1] = td->td_retval[1]; + frame->tf_r0 = td->td_retval[0]; + frame->tf_r1 = td->td_retval[1]; frame->tf_spsr &= ~PSR_C; break; case ERESTART: /* Restart system call. */ - frame->tf_elr -= 4; + frame->tf_pc -= 4; break; case EJUSTRETURN: break; default: /* System call returned an error. */ - frame->tf_x[0] = cloudabi_convert_errno(error); + frame->tf_r0 = cloudabi_convert_errno(error); frame->tf_spsr |= PSR_C; break; } } static void -cloudabi64_schedtail(struct thread *td) +cloudabi32_schedtail(struct thread *td) { struct trapframe *frame = td->td_frame; @@ -126,14 +134,14 @@ cloudabi64_schedtail(struct thread *td) * when creating a new thread. */ if ((td->td_pflags & TDP_FORKING) != 0) { - frame->tf_x[0] = CLOUDABI_PROCESS_CHILD; - frame->tf_x[1] = td->td_tid; + frame->tf_r0 = CLOUDABI_PROCESS_CHILD; + frame->tf_r1 = td->td_tid; } } int -cloudabi64_thread_setregs(struct thread *td, - const cloudabi64_threadattr_t *attr, uint64_t tcb) +cloudabi32_thread_setregs(struct thread *td, + const cloudabi32_threadattr_t *attr, uint32_t tcb) { struct trapframe *frame; stack_t stack; @@ -149,38 +157,37 @@ cloudabi64_thread_setregs(struct thread * entry point. */ frame = td->td_frame; - frame->tf_x[0] = td->td_tid; - frame->tf_x[1] = attr->argument; + frame->tf_r0 = td->td_tid; + frame->tf_r1 = attr->argument; /* Set up TLS. */ return (cpu_set_user_tls(td, (void *)tcb)); } -static struct sysentvec cloudabi64_elf_sysvec = { - .sv_size = CLOUDABI64_SYS_MAXSYSCALL, - .sv_table = cloudabi64_sysent, - .sv_fixup = cloudabi64_fixup, - .sv_name = "CloudABI ELF64", - .sv_coredump = elf64_coredump, +static struct sysentvec cloudabi32_elf_sysvec = { + .sv_size = CLOUDABI32_SYS_MAXSYSCALL, + .sv_table = cloudabi32_sysent, + .sv_fixup = cloudabi32_fixup, + .sv_name = "CloudABI ELF32", + .sv_coredump = elf32_coredump, .sv_pagesize = PAGE_SIZE, .sv_minuser = VM_MIN_ADDRESS, .sv_maxuser = VM_MAXUSER_ADDRESS, .sv_stackprot = VM_PROT_READ | VM_PROT_WRITE, - .sv_copyout_strings = cloudabi64_copyout_strings, - .sv_setregs = cloudabi64_proc_setregs, - .sv_flags = SV_ABI_CLOUDABI | SV_CAPSICUM | SV_LP64, - .sv_set_syscall_retval = cloudabi64_set_syscall_retval, - .sv_fetch_syscall_args = cloudabi64_fetch_syscall_args, - .sv_syscallnames = cloudabi64_syscallnames, - .sv_schedtail = cloudabi64_schedtail, + .sv_copyout_strings = cloudabi32_copyout_strings, + .sv_setregs = cloudabi32_proc_setregs, + .sv_flags = SV_ABI_CLOUDABI | SV_CAPSICUM | SV_ILP32, + .sv_set_syscall_retval = cloudabi32_set_syscall_retval, + .sv_fetch_syscall_args = cloudabi32_fetch_syscall_args, + .sv_syscallnames = cloudabi32_syscallnames, + .sv_schedtail = cloudabi32_schedtail, }; -INIT_SYSENTVEC(elf_sysvec, &cloudabi64_elf_sysvec); +INIT_SYSENTVEC(elf_sysvec, &cloudabi32_elf_sysvec); -Elf64_Brandinfo cloudabi64_brand = { +Elf32_Brandinfo cloudabi32_brand = { .brand = ELFOSABI_CLOUDABI, - .machine = EM_AARCH64, - .sysvec = &cloudabi64_elf_sysvec, - .flags = BI_CAN_EXEC_DYN, + .machine = EM_ARM, + .sysvec = &cloudabi32_elf_sysvec, .compat_3_brand = "CloudABI", }; Modified: head/sys/conf/files.arm ============================================================================== --- head/sys/conf/files.arm Sun Sep 18 10:06:35 2016 (r305927) +++ head/sys/conf/files.arm Sun Sep 18 11:36:54 2016 (r305928) @@ -1,4 +1,16 @@ # $FreeBSD$ +cloudabi32_vdso.o optional compat_cloudabi32 \ + dependency "$S/contrib/cloudabi/cloudabi_vdso_armv6.S" \ + compile-with "${CC} -x assembler-with-cpp -shared -nostdinc -nostdlib -Wl,-T$S/compat/cloudabi/cloudabi_vdso.lds $S/contrib/cloudabi/cloudabi_vdso_armv6.S -o ${.TARGET}" \ + no-obj no-implicit-rule \ + clean "cloudabi32_vdso.o" +# +cloudabi32_vdso_blob.o optional compat_cloudabi32 \ + dependency "cloudabi32_vdso.o" \ + compile-with "${OBJCOPY} --input-target binary --output-target elf32-littlearm --binary-architecture arm cloudabi32_vdso.o ${.TARGET}" \ + no-implicit-rule \ + clean "cloudabi32_vdso_blob.o" +# arm/annapurna/alpine/alpine_ccu.c optional al_ccu fdt arm/annapurna/alpine/alpine_nb_service.c optional al_nb_service fdt arm/arm/autoconf.c standard @@ -85,6 +97,7 @@ arm/arm/undefined.c standard arm/arm/unwind.c optional ddb | kdtrace_hooks arm/arm/vm_machdep.c standard arm/arm/vfp.c standard +arm/cloudabi32/cloudabi32_sysvec.c optional compat_cloudabi32 board_id.h standard \ dependency "$S/arm/conf/genboardid.awk $S/arm/conf/mach-types" \ compile-with "${AWK} -f $S/arm/conf/genboardid.awk $S/arm/conf/mach-types > board_id.h" \ Added: head/sys/contrib/cloudabi/cloudabi_vdso_armv6.S ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/contrib/cloudabi/cloudabi_vdso_armv6.S Sun Sep 18 11:36:54 2016 (r305928) @@ -0,0 +1,490 @@ +// Copyright (c) 2016 Nuxi (https://nuxi.nl/) and contributors. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +// SUCH DAMAGE. +// +// This file is automatically generated. Do not edit. +// +// Source: https://github.com/NuxiNL/cloudabi + +#define ENTRY(name) \ + .text; \ + .p2align 2; \ + .global name; \ + .type name, %function; \ +name: + +#define END(name) .size name, . - name + +ENTRY(cloudabi_sys_clock_res_get) + str r1, [sp, #-4] + mov ip, #0 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2, 0] + str r1, [r2, 4] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_clock_res_get) + +ENTRY(cloudabi_sys_clock_time_get) + str r3, [sp, #-4] + mov ip, #1 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2, 0] + str r1, [r2, 4] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_clock_time_get) + +ENTRY(cloudabi_sys_condvar_signal) + mov ip, #2 + swi 0 + bx lr +END(cloudabi_sys_condvar_signal) + +ENTRY(cloudabi_sys_fd_close) + mov ip, #3 + swi 0 + bx lr +END(cloudabi_sys_fd_close) + +ENTRY(cloudabi_sys_fd_create1) + str r1, [sp, #-4] + mov ip, #4 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_create1) + +ENTRY(cloudabi_sys_fd_create2) + str r1, [sp, #-4] + str r2, [sp, #-8] + mov ip, #5 + swi 0 + ldr r2, [sp, #-4] + ldr r3, [sp, #-8] + bcs 1f + str r0, [r2] + str r1, [r3] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_create2) + +ENTRY(cloudabi_sys_fd_datasync) + mov ip, #6 + swi 0 + bx lr +END(cloudabi_sys_fd_datasync) + +ENTRY(cloudabi_sys_fd_dup) + str r1, [sp, #-4] + mov ip, #7 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_dup) + +ENTRY(cloudabi_sys_fd_pread) + mov ip, #8 + swi 0 + bcs 1f + ldr r2, [sp, #8] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_pread) + +ENTRY(cloudabi_sys_fd_pwrite) + mov ip, #9 + swi 0 + bcs 1f + ldr r2, [sp, #8] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_pwrite) + +ENTRY(cloudabi_sys_fd_read) + str r3, [sp, #-4] + mov ip, #10 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_read) + +ENTRY(cloudabi_sys_fd_replace) + mov ip, #11 + swi 0 + bx lr +END(cloudabi_sys_fd_replace) + +ENTRY(cloudabi_sys_fd_seek) + mov ip, #12 + swi 0 + bcs 1f + ldr r2, [sp, #4] + str r0, [r2, 0] + str r1, [r2, 4] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_seek) + +ENTRY(cloudabi_sys_fd_stat_get) + mov ip, #13 + swi 0 + bx lr +END(cloudabi_sys_fd_stat_get) + +ENTRY(cloudabi_sys_fd_stat_put) + mov ip, #14 + swi 0 + bx lr +END(cloudabi_sys_fd_stat_put) + +ENTRY(cloudabi_sys_fd_sync) + mov ip, #15 + swi 0 + bx lr +END(cloudabi_sys_fd_sync) + +ENTRY(cloudabi_sys_fd_write) + str r3, [sp, #-4] + mov ip, #16 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_fd_write) + +ENTRY(cloudabi_sys_file_advise) + mov ip, #17 + swi 0 + bx lr +END(cloudabi_sys_file_advise) + +ENTRY(cloudabi_sys_file_allocate) + mov ip, #18 + swi 0 + bx lr +END(cloudabi_sys_file_allocate) + +ENTRY(cloudabi_sys_file_create) + mov ip, #19 + swi 0 + bx lr +END(cloudabi_sys_file_create) + +ENTRY(cloudabi_sys_file_link) + mov ip, #20 + swi 0 + bx lr +END(cloudabi_sys_file_link) + +ENTRY(cloudabi_sys_file_open) + mov ip, #21 + swi 0 + bcs 1f + ldr r2, [sp, #12] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_file_open) + +ENTRY(cloudabi_sys_file_readdir) + mov ip, #22 + swi 0 + bcs 1f + ldr r2, [sp, #8] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_file_readdir) + +ENTRY(cloudabi_sys_file_readlink) + mov ip, #23 + swi 0 + bcs 1f + ldr r2, [sp, #8] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_file_readlink) + +ENTRY(cloudabi_sys_file_rename) + mov ip, #24 + swi 0 + bx lr +END(cloudabi_sys_file_rename) + +ENTRY(cloudabi_sys_file_stat_fget) + mov ip, #25 + swi 0 + bx lr +END(cloudabi_sys_file_stat_fget) + +ENTRY(cloudabi_sys_file_stat_fput) + mov ip, #26 + swi 0 + bx lr +END(cloudabi_sys_file_stat_fput) + +ENTRY(cloudabi_sys_file_stat_get) + mov ip, #27 + swi 0 + bx lr +END(cloudabi_sys_file_stat_get) + +ENTRY(cloudabi_sys_file_stat_put) + mov ip, #28 + swi 0 + bx lr +END(cloudabi_sys_file_stat_put) + +ENTRY(cloudabi_sys_file_symlink) + mov ip, #29 + swi 0 + bx lr +END(cloudabi_sys_file_symlink) + +ENTRY(cloudabi_sys_file_unlink) + mov ip, #30 + swi 0 + bx lr +END(cloudabi_sys_file_unlink) + +ENTRY(cloudabi_sys_lock_unlock) + mov ip, #31 + swi 0 + bx lr +END(cloudabi_sys_lock_unlock) + +ENTRY(cloudabi_sys_mem_advise) + mov ip, #32 + swi 0 + bx lr +END(cloudabi_sys_mem_advise) + +ENTRY(cloudabi_sys_mem_lock) + mov ip, #33 + swi 0 + bx lr +END(cloudabi_sys_mem_lock) + +ENTRY(cloudabi_sys_mem_map) + mov ip, #34 + swi 0 + bcs 1f + ldr r2, [sp, #16] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_mem_map) + +ENTRY(cloudabi_sys_mem_protect) + mov ip, #35 + swi 0 + bx lr +END(cloudabi_sys_mem_protect) + +ENTRY(cloudabi_sys_mem_sync) + mov ip, #36 + swi 0 + bx lr +END(cloudabi_sys_mem_sync) + +ENTRY(cloudabi_sys_mem_unlock) + mov ip, #37 + swi 0 + bx lr +END(cloudabi_sys_mem_unlock) + +ENTRY(cloudabi_sys_mem_unmap) + mov ip, #38 + swi 0 + bx lr +END(cloudabi_sys_mem_unmap) + +ENTRY(cloudabi_sys_poll) + str r3, [sp, #-4] + mov ip, #39 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_poll) + +ENTRY(cloudabi_sys_poll_fd) + mov ip, #40 + swi 0 + bcs 1f + ldr r2, [sp, #12] + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_poll_fd) + +ENTRY(cloudabi_sys_proc_exec) + mov ip, #41 + swi 0 + bx lr +END(cloudabi_sys_proc_exec) + +ENTRY(cloudabi_sys_proc_exit) + mov ip, #42 + swi 0 +END(cloudabi_sys_proc_exit) + +ENTRY(cloudabi_sys_proc_fork) + str r0, [sp, #-4] + str r1, [sp, #-8] + mov ip, #43 + swi 0 + ldr r2, [sp, #-4] + ldr r3, [sp, #-8] + bcs 1f + str r0, [r2] + str r1, [r3] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_proc_fork) + +ENTRY(cloudabi_sys_proc_raise) + mov ip, #44 + swi 0 + bx lr +END(cloudabi_sys_proc_raise) + +ENTRY(cloudabi_sys_random_get) + mov ip, #45 + swi 0 + bx lr +END(cloudabi_sys_random_get) + +ENTRY(cloudabi_sys_sock_accept) + str r2, [sp, #-4] + mov ip, #46 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_sock_accept) + +ENTRY(cloudabi_sys_sock_bind) + mov ip, #47 + swi 0 + bx lr +END(cloudabi_sys_sock_bind) + +ENTRY(cloudabi_sys_sock_connect) + mov ip, #48 + swi 0 + bx lr +END(cloudabi_sys_sock_connect) + +ENTRY(cloudabi_sys_sock_listen) + mov ip, #49 + swi 0 + bx lr +END(cloudabi_sys_sock_listen) + +ENTRY(cloudabi_sys_sock_recv) + mov ip, #50 + swi 0 + bx lr +END(cloudabi_sys_sock_recv) + +ENTRY(cloudabi_sys_sock_send) + mov ip, #51 + swi 0 + bx lr +END(cloudabi_sys_sock_send) + +ENTRY(cloudabi_sys_sock_shutdown) + mov ip, #52 + swi 0 + bx lr +END(cloudabi_sys_sock_shutdown) + +ENTRY(cloudabi_sys_sock_stat_get) + mov ip, #53 + swi 0 + bx lr +END(cloudabi_sys_sock_stat_get) + +ENTRY(cloudabi_sys_thread_create) + str r1, [sp, #-4] + mov ip, #54 + swi 0 + ldr r2, [sp, #-4] + bcs 1f + str r0, [r2] + mov r0, $0 +1: + bx lr +END(cloudabi_sys_thread_create) + +ENTRY(cloudabi_sys_thread_exit) + mov ip, #55 + swi 0 +END(cloudabi_sys_thread_exit) + +ENTRY(cloudabi_sys_thread_yield) + mov ip, #56 + swi 0 + bx lr +END(cloudabi_sys_thread_yield)