Port command-line arguments to use wasip2 methods (#609)

Co-authored-by: Pat Hickey <[email protected]>

Author: catamorphism

libc-bottom-half/sources/__main_void.c

@@ -1,4 +1,8 @@
+#ifdef __wasilibc_use_wasip2
+#include <wasi/wasip2.h>
+#else
 #include <wasi/api.h>
+#endif
 #include <stdlib.h>
 #include <sysexits.h>
 
@@ -21,6 +25,46 @@ int __main_argc_argv(int argc, char *argv[]);
 // (e.g. crt0.o or crtend.o) and teach Clang to use it when needed.
 __attribute__((__weak__, nodebug))
 int __main_void(void) {
+#ifdef __wasilibc_use_wasip2
+    wasip2_list_string_t argument_list;
+
+    environment_get_arguments(&argument_list);
+
+    // Add 1 for the NULL pointer to mark the end, and check for overflow.
+    size_t argc = argument_list.len;
+    size_t num_ptrs = argc + 1;
+    if (num_ptrs == 0) {
+        wasip2_list_string_free(&argument_list);
+        _Exit(EX_SOFTWARE);
+    }
+
+    // Allocate memory for the array of pointers. This uses `calloc` both to
+    // handle overflow and to initialize the NULL pointer at the end.
+    char **argv = calloc(num_ptrs, sizeof(char *));
+    if (argv == NULL) {
+        wasip2_list_string_free(&argument_list);
+        _Exit(EX_SOFTWARE);
+    }
+
+    // Copy the arguments
+    for (size_t i = 0; i < argc; i++) {
+        wasip2_string_t wasi_string = argument_list.ptr[i];
+        size_t len = wasi_string.len;
+        argv[i] = malloc(len + 1);
+        if (!argv[i]) {
+            wasip2_list_string_free(&argument_list);
+            _Exit(EX_SOFTWARE);
+        }
+        memcpy(argv[i], wasi_string.ptr, len);
+        argv[i][len] = '\0';
+    }
+
+    // Free the WASI argument list
+    wasip2_list_string_free(&argument_list);
+
+    // Call `__main_argc_argv` with the arguments!
+    return __main_argc_argv(argc, argv);
+#else
     __wasi_errno_t err;
 
     // Get the sizes of the arrays we'll have to create to copy in the args.
@@ -62,4 +106,5 @@ int __main_void(void) {
 
     // Call `__main_argc_argv` with the arguments!
     return __main_argc_argv(argc, argv);
+#endif
 }

test/Makefile

@@ -212,6 +212,7 @@ $(RUNDIR)/%/success: $(OBJPAT)
 	@DIR="$(abspath $(@D))" \
 	  WASM="$(abspath $<)" \
 	  ENGINE="$(ENGINE) $(shell scripts/add-flags.py RUN $(call wasm_to_c,$<))" \
+          ARGS="$(shell scripts/add-flags.py ARGS $(call wasm_to_c,$<))" \
 	    scripts/run-test.sh
 
 # Use the provided Wasm engine to execute each test, emitting its output into

test/scripts/browser-test/harness.mjs

@@ -24,6 +24,8 @@ const SKIP_TESTS = [
     // atomic.wait32 can't be executed on the main thread
     "libc-test/functional/pthread_mutex",
     "libc-test/functional/pthread_tsd",
+    // Skip test that uses command-line arguments
+    "misc/argv_two_args",
     // XFAIL: @bjorn3/browser_wasi_shim doesn't support symlinks for now
     "misc/fts",
 ];

test/scripts/run-test.sh

@@ -6,15 +6,15 @@
 # - a `fs` directory which the test may have used for file IO
 # - an `output.log` file containing the output of the test
 #
-# Usage: DIR=... WASM=... ENGINE=... ./run-test.sh
+# Usage: DIR=... WASM=... ENGINE=... ARGS="..." ./run-test.sh
 
 ENGINE="${ENGINE:-wasmtime}"
 [ -n "$WASM" ] || (echo "missing WASM variable" && exit 1)
 [ -n "$DIR" ] || (echo "missing DIR variable" && exit 1)
 
 cd $DIR
 mkdir -p fs
-echo "$ENGINE $WASM" > cmd.sh
+echo "$ENGINE $WASM $ARGS" > cmd.sh
 chmod +x cmd.sh
 ./cmd.sh &> output.log
 [ $? -eq 0 ] || echo "Test failed" >> output.log

test/src/misc/argv_two_args.c

@@ -0,0 +1,24 @@
+//! add-flags.py(CFLAGS): -I.
+//! add-flags.py(ARGS): foo bar
+#include <limits.h>
+#include <stdio.h>
+#include "test.h"
+
+#define TEST(c, ...) \
+	( (c) || (t_error(#c " failed: " __VA_ARGS__),0) )
+
+int main(int argc, char **argv)
+{
+        char buf[PATH_MAX];
+        TEST(argc == 3, "argc should be 3\n");
+        TEST(argv[0] != 0, "argv[0] should not be NULL\n");
+        TEST(argv[1] != 0, "argv[1] should not be NULL\n");
+        TEST(argv[2] != 0, "argv[2] should not be NULL\n");
+        TEST(argv[3] == NULL, "argv[3] should be NULL\n");
+
+        for (int i = 0; i < argc; i++) {
+            TEST(argv[i][0] != 0, "argument should not be empty\n");
+            TEST(snprintf(buf, sizeof buf, "%s", argv[i]) < sizeof buf, "argument is not a valid path\n");
+        }
+        return t_status;
+}