From df9ddb1e4eb144f74157e08b86e7b8c50d0d225c Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 19 Mar 2024 19:16:24 +0100
Subject: [PATCH 01/11] printf the hell out of it, ongoing

---
 src/gas/gas.cc         | 10 ++++++++++
 src/gas/gas.hh         |  1 -
 src/gas/gas.windows.cc | 21 +++++++++++++++++----
 src/gas/main.cc        |  6 ++++--
 4 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index 7efd933..6c0bc6d 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -58,7 +58,9 @@ int Gas::usage (bool is_error, std::string const message)
 
 int Gas::run (int argc, char **argv)
 {
+	std::cout << "Gas::run" << std::endl;
 	determine_program_dir (argc, argv);
+	std::cout << "Program dir determined" << std::endl;
 
 	auto lowercase_string = [](std::string& s) {
 		std::transform (
@@ -69,12 +71,14 @@ int Gas::run (int argc, char **argv)
 		);
 	};
 
+	std::cout << "Determining arch name" << std::endl;
 	std::string arch_name { generic_gas_name };
 	const char *first_param = argc > 1 ? argv[1] : nullptr;
 	if (first_param != nullptr && strlen (first_param) > sizeof(Constants::arch_hack_param) && strstr (first_param, Constants::arch_hack_param) == first_param) {
 		arch_name = first_param + (sizeof(Constants::arch_hack_param) - 1);
 		lowercase_string (arch_name);
 	}
+	std::cout << "arch_name == " << arch_name << std::endl;
 	_program_name = arch_name;
 
 	std::unique_ptr<LlvmMcRunner> mc_runner;
@@ -112,12 +116,16 @@ int Gas::run (int argc, char **argv)
 		return usage (true /* is_error */, message);
 	}
 
+	std::cout << "About to parse arguments" << std::endl;
 	auto&& [terminate, is_error] = parse_arguments (argc, argv, mc_runner);
+	std::cout << "Arguments parsed; terminate == " << terminate << "; is_error == " << is_error << std::endl;
 	if (terminate || is_error) {
 		return is_error ? Constants::wrapper_general_error_code : 0;
 	}
 
+	std::cout << "Getting path to llvm_mc" << std::endl;
 	fs::path llvm_mc = program_dir () / Constants::llvm_mc_name;
+	std::wcout << "llvm_mc == " << llvm_mc.c_str () << std::endl;
 
 	bool multiple_input_files = false;
 	bool derive_output_file_name = false;
@@ -141,9 +149,11 @@ int Gas::run (int argc, char **argv)
 	}
 
 	for (fs::path const& input : input_files) {
+		std::wcout << "running llvm-mc for '" << input.c_str () << std::endl;
 		mc_runner->set_input_file_path (input, derive_output_file_name);
 		int ret = mc_runner->run (llvm_mc);
 		if (ret != 0) {
+			std::cout << "  mc_runner failed with " << ret << std::endl;
 			return ret;
 		}
 	}
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index ee5fa39..f3bfd60 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -217,5 +217,4 @@ namespace xamarin::android::gas
 	};
 }
 
-extern xamarin::android::gas::Gas app;
 #endif // __GAS_HH
diff --git a/src/gas/gas.windows.cc b/src/gas/gas.windows.cc
index cef3a3f..fcfcf28 100644
--- a/src/gas/gas.windows.cc
+++ b/src/gas/gas.windows.cc
@@ -2,12 +2,9 @@
 #include <windows.h>
 #include <shlwapi.h>
 
-#include <algorithm>
 #include <cstring>
 #include <iostream>
-#include <string>
 
-#include "constants.hh"
 #include "exceptions.hh"
 #include "gas.hh"
 
@@ -17,11 +14,27 @@ void Gas::get_command_line (int &argc, char **&argv)
 {
 	LPWSTR *argvw = CommandLineToArgvW (GetCommandLineW (), &argc);
 	argv = new char*[argc + 1];
-
+	memset (argv, 0, argc * sizeof(char*));
 	for (int i = 0; i < argc; i++) {
+		std::cout << "Argument " << i << std::endl;
 		int size = WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, NULL, 0, NULL, NULL);
+		std::cout << "  size: " << size << std::endl;
+		if (size <= 0) {
+			// An error, but we ignore it and try to get the other arguments converted.
+			argv[i] = _strdup ("");
+			continue;
+		}
+
 		argv [i] = new char [size];
+		memset (argv [i], 0, size * sizeof(char));
+		std::cout << "  copying" << std::endl;
 		WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, argv [i], size, NULL, NULL);
+		std::cout << "  copied" << std::endl;
+	}
+
+	std::cout << "Processed arguments: " << std::endl;
+	for (int i = 0; i < argc; i++) {
+		std::cout << "  [" << i << "] " << argv[i] << std::endl;
 	}
 
 	argv [argc] = NULL;
diff --git a/src/gas/main.cc b/src/gas/main.cc
index 9b77d0e..4785f13 100644
--- a/src/gas/main.cc
+++ b/src/gas/main.cc
@@ -1,12 +1,14 @@
 // SPDX-License-Identifier: MIT
+#include <iostream>
 #include "gas.hh"
 
-xamarin::android::gas::Gas app;
-
 int main (int argc, char **argv)
 {
+	xamarin::android::gas::Gas app;
+
 	// On windows this obtains the utf8 version of args
 	app.get_command_line (argc, argv);
+	std::cout << "Command line converted" << std::endl;
 	// TODO: handle exceptions here (use backward for stacktrace perhaps?)
 	return app.run (argc, argv);
 }

From c5e394297d1baaa3123753f6f171f3feccfe4355 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Thu, 21 Mar 2024 19:36:47 +0100
Subject: [PATCH 02/11] Custom command line parser

Better option than porting getopt to Windows
---
 src/gas/CMakeLists.txt  |   1 +
 src/gas/command_line.cc |  77 +++++++++++++++++++++++
 src/gas/command_line.hh | 135 ++++++++++++++++++++++++++++++++++++++++
 src/gas/constants.hh    |   9 +++
 src/gas/gas.cc          |  56 +++++++++++++++--
 src/gas/gas.hh          |  15 ++---
 6 files changed, 279 insertions(+), 14 deletions(-)
 create mode 100644 src/gas/command_line.cc
 create mode 100644 src/gas/command_line.hh

diff --git a/src/gas/CMakeLists.txt b/src/gas/CMakeLists.txt
index ced38a4..31aaefc 100644
--- a/src/gas/CMakeLists.txt
+++ b/src/gas/CMakeLists.txt
@@ -1,4 +1,5 @@
 set(GAS_DRIVER_SOURCES
+  command_line.cc
   gas.cc
   llvm_mc_runner.cc
   llvm_mc_runner_arm32.cc
diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
new file mode 100644
index 0000000..905d106
--- /dev/null
+++ b/src/gas/command_line.cc
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+
+#include <algorithm>
+#include <iostream>
+
+#include "command_line.hh"
+
+using namespace xamarin::android::gas;
+namespace ranges = std::ranges;
+
+bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb)
+{
+	stdout() << "Got " << options.size() << " options\n" << "Passed args:\n";
+
+	uint32_t positional_count = 0;
+	bool next_must_be_positional = false;
+
+	for (int i = 1; i < argc; i++) {
+		TOptionString option { argv[i] };
+		if (option.empty ()) {
+			continue;
+		}
+
+		stdout() << "  [" << i << "] " << option << "\n";
+
+		TOptionString::const_iterator iter = option.cbegin ();
+
+		while (iter != option.cend () && *iter == DASH) {
+			iter++;
+		}
+		bool positional = iter == option.cbegin ();
+		stdout() << std::boolalpha << "    Positional? " << positional << "\n";
+
+		CommandLineStringView option_name;
+		CommandLineStringView option_value;
+		if (positional) {
+			option_cb ({ positional_count++ }, { option });
+			continue;
+		}
+
+		TOptionString::const_iterator name_start = iter;
+
+		while (iter != option.cend () && *iter != EQUALS) {
+			iter++;
+		}
+
+		option_name = { name_start, iter };
+
+		bool has_value = iter != option.cend ();
+		stdout() << "    Has value? " << has_value << "\n";
+
+		if (has_value) {
+			iter++;
+			option_value = { iter, option.cend () };
+		}
+
+		stdout() << "     Option name: " << TOptionString (option_name) << "\n";
+		stdout() << "    Option value: " << TOptionString (option_value) << "\n";
+
+		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {
+			if (o.name != option_name) {
+				return false;
+			}
+
+			return o.arch == TargetArchitecture::Any || o.arch == target_arch;
+		};
+
+		auto match = ranges::find_if (options, matching_option);
+		if (match != options.end ()) {
+			stdout() << "    found matching option\n";
+		} else {
+			stderr() << "Uncrecognized option '" << option << "'\n";
+		}
+	}
+
+	return true;
+}
diff --git a/src/gas/command_line.hh b/src/gas/command_line.hh
new file mode 100644
index 0000000..0b79974
--- /dev/null
+++ b/src/gas/command_line.hh
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: MIT
+#if !defined (GAS_COMMAND_LINE_HH)
+#define GAS_COMMAND_LINE_HH
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <span>
+#include <string>
+#include <variant>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+#include "constants.hh"
+
+namespace xamarin::android::gas
+{
+#if !defined (_WIN32)
+	using CommandLineString = std::string;
+	using CommandLineStringView = std::string_view;
+#else
+	using CommandLineString = std::wstring;
+	using CommandLineStringView = std::wstring_view;
+#endif
+
+	enum class Argument
+	{
+		Required,
+		NotRequired,
+	};
+
+	struct CommandLineOption
+	{
+		CommandLineStringView name;
+		uint32_t id;
+		Argument argument;
+		TargetArchitecture arch;
+
+		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, Argument _argument, TargetArchitecture _arch)
+			: name (_name),
+			  id (_id),
+			  argument (_argument),
+			  arch (_arch)
+		{}
+
+		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, TargetArchitecture _arch)
+			: CommandLineOption (_name, _id, Argument::NotRequired, _arch)
+		{}
+
+		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, Argument _argument)
+			: CommandLineOption (_name, _id, _argument, TargetArchitecture::Any)
+		{}
+
+		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id)
+			: CommandLineOption (_name, _id, Argument::NotRequired, TargetArchitecture::Any)
+		{}
+	};
+
+	class CommandLine
+	{
+#if !defined(_WIN32)
+		static constexpr bool is_windows = false;
+#else
+		static constexpr bool is_windows = true;
+#endif
+
+	public:
+#if !defined(_WIN32)
+		using TArgType = char*;
+		using TOptionString = std::string;
+
+	private:
+		static inline constexpr char DASH = '-';
+		static inline constexpr char EQUALS = '=';
+#else
+		using TArgType = LPWSTR;
+		using TOptionString = std::wstring;
+
+	private:
+		static inline constexpr wchar_t DASH = L'-';
+		static inline constexpr wchar_t EQUALS = L'=';
+#endif
+
+	public:
+		using TOptionValue = std::variant<bool, TOptionString>;
+		using TCallbackOption = std::variant<uint32_t, const CommandLineOption>;
+		using OptionCallbackFn = std::function<void(TCallbackOption option, TOptionValue val)>;
+
+	public:
+		explicit CommandLine (TargetArchitecture _target_arch) noexcept
+			: target_arch (_target_arch)
+		{}
+
+		template<size_t NElem>
+		bool parse (std::array<CommandLineOption, NElem> const& options, int argc, TArgType *argv, OptionCallbackFn option_cb)
+		{
+			return parse (std::span (options.data(), options.size()), argc, argv, option_cb);
+		}
+
+	private:
+		bool parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb);
+
+		static constexpr auto& stdout () noexcept
+		{
+			if constexpr (is_windows) {
+				return std::wcout;
+			} else {
+				return std::cout;
+			}
+		}
+
+		static constexpr auto& stderr () noexcept
+		{
+			if constexpr (is_windows) {
+				return std::wcerr;
+			} else {
+				return std::cerr;
+			}
+		}
+
+	private:
+		TargetArchitecture target_arch;
+	};
+}
+
+#if !defined (_WIN32)
+#define CLISTR(_str_lit_) std::string_view { _str_lit_ }
+#else
+#define CLISTR(_str_lit_) std::wstring_view { L##_str_lit_ }
+#endif
+
+#endif // ndef GAS_COMMAND_LINE_HH
diff --git a/src/gas/constants.hh b/src/gas/constants.hh
index 6c28835..253bc57 100644
--- a/src/gas/constants.hh
+++ b/src/gas/constants.hh
@@ -23,5 +23,14 @@ namespace xamarin::android::gas
 		static constexpr int wrapper_exec_failed_error_code     = wrapper_general_error_code + 4;
 		static constexpr int wrapper_wait_failed_error_code     = wrapper_general_error_code + 5;
 	};
+
+	enum class TargetArchitecture
+	{
+		Any,
+		ARM32,
+		ARM64,
+		X86,
+		X64,
+	};
 }
 #endif
diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index 6c0bc6d..c3b36a5 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -3,10 +3,12 @@
 #include <unistd.h>
 #endif
 
+#include <array>
 #include <cstring>
 #include <iostream>
 #include <filesystem>
 
+#include "command_line.hh"
 #include "constants.hh"
 #include "gas.hh"
 #include "llvm_mc_runner.hh"
@@ -183,6 +185,41 @@ int Gas::run (int argc, char **argv)
 	return 0;
 }
 
+constexpr std::array<CommandLineOption, 21> all_options {{
+	// Arguments ignored by GAS, we shall ignore them silently too
+	{ CLISTR("divide"),    OPTION_IGNORE },
+	{ CLISTR("k"),         OPTION_IGNORE },
+	{ CLISTR("nocpp"),     OPTION_IGNORE },
+	{ CLISTR("Qn"),        OPTION_IGNORE },
+	{ CLISTR("Qy"),        OPTION_IGNORE },
+	{ CLISTR("s"),         OPTION_IGNORE },
+	{ CLISTR("w"),         OPTION_IGNORE },
+	{ CLISTR("X"),         OPTION_IGNORE },
+
+	// Global GAS arguments we support
+	{ CLISTR("o"),         OPTION_O,              Argument::Required },
+	{ CLISTR("warn"),      OPTION_WARN },
+	{ CLISTR("g"),         OPTION_G },
+	{ CLISTR("gen-debug"), OPTION_G },
+
+	// Arguments handled by us, not passed to llvm-mc
+	{ CLISTR("h"),         OPTION_HELP },
+	{ CLISTR("help"),      OPTION_HELP },
+	{ CLISTR("V"),         OPTION_VERSION },
+	{ CLISTR("version"),   OPTION_VERSION_EXIT },
+
+	// x86 arguments
+	{ CLISTR("32"),        OPTION_IGNORE,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
+	{ CLISTR("64"),        OPTION_IGNORE,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
+
+	// x64 arguments
+	{ CLISTR("32"),        OPTION_IGNORE,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
+	{ CLISTR("64"),        OPTION_IGNORE,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
+
+	// Arm32 arguments
+	{ CLISTR("mfpu"),      OPTION_MFPU,           Argument::Required, TargetArchitecture::ARM32 },
+}};
+
 std::vector<option> Gas::common_options {
 	// Arguments ignored by GAS, we shall ignore them silently too
 	{ "divide",    no_argument,       nullptr, OPTION_IGNORE },
@@ -216,8 +253,22 @@ std::vector<option> Gas::arm32_options {
 	{ "mfpu", required_argument, nullptr, OPTION_MFPU },
 };
 
-Gas::ParseArgsResult Gas::parse_arguments (int argc, char **argv, std::unique_ptr<LlvmMcRunner>& mc_runner)
+Gas::ParseArgsResult Gas::parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner)
 {
+	bool terminate = false, is_error = false;
+	bool show_version = false, show_help = false;
+
+	auto handle_arg = [&](CommandLine::TCallbackOption option, CommandLine::TOptionValue val) {
+		if (std::holds_alternative<uint32_t> (option)) {
+			// Positional argument
+			std::cout << "Positional argument no. " << std::get<uint32_t> (option) << ": " << std::get<CommandLine::TOptionString> (val) << "\n";
+			return;
+		}
+	};
+
+	CommandLine cmdline { target_arch () };
+	bool valid = cmdline.parse (all_options, argc, argv, handle_arg);
+
 	std::vector<option> long_options { common_options };
 
 	switch (target_arch ()) {
@@ -237,9 +288,6 @@ Gas::ParseArgsResult Gas::parse_arguments (int argc, char **argv, std::unique_pt
 
 	constexpr char PROGRAM_DESCRIPTION[] = "Xamarin.Android GAS adapter for llvm-mc";
 
-	bool terminate = false, is_error = false;
-	bool show_version = false, show_help = false;
-
 	while (true) {
 		int opt_index = 0;
 		int c = getopt_long_only (argc, argv, "-", long_options.data (), &opt_index);
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index f3bfd60..aac183a 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -18,6 +18,9 @@
 #include <concepts>
 #endif // has <concepts>
 
+#include "command_line.hh"
+#include "constants.hh"
+
 namespace xamarin::android::gas
 {
 	namespace fs = std::filesystem;
@@ -49,14 +52,6 @@ namespace xamarin::android::gas
 
 	class LlvmMcRunner;
 
-	enum class TargetArchitecture
-	{
-		ARM32,
-		ARM64,
-		X86,
-		X64,
-	};
-
 	enum OptionValues
 	{
 		OPTION_IGNORE = 100,
@@ -169,7 +164,7 @@ namespace xamarin::android::gas
 
 		void get_command_line (int &argc, char **&argv);
 
-		int run (int argc, char **argv);
+		int run (int argc, CommandLine::TArgType *argv);
 
 		const std::string& program_name () const noexcept
 		{
@@ -187,7 +182,7 @@ namespace xamarin::android::gas
 		}
 
 	protected:
-		ParseArgsResult parse_arguments (int argc, char **argv, std::unique_ptr<LlvmMcRunner>& mc_runner);
+		ParseArgsResult parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner);
 
 	private:
 		void determine_program_dir (int argc, char **argv);

From c37ae9308163d390fdf8b8729883a41943529ab9 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Fri, 22 Mar 2024 17:44:53 +0100
Subject: [PATCH 03/11] [WIP] Migration to std::wstring and wchar_t on Windows
 side

Windows doesn't build yet, Unix side works.
---
 src/compat/getopt.c             | 562 --------------------------------
 src/gas/CMakeLists.txt          |   1 -
 src/gas/command_line.cc         |  61 +++-
 src/gas/command_line.hh         |  69 ++--
 src/gas/constants.hh            |  14 +-
 src/gas/gas.cc                  | 240 ++++++--------
 src/gas/gas.hh                  | 153 ++++-----
 src/gas/gas.windows.cc          |   2 +-
 src/gas/llvm_mc_runner.cc       |  19 +-
 src/gas/llvm_mc_runner.hh       |  54 +--
 src/gas/llvm_mc_runner_arm32.cc |  98 +++---
 src/gas/llvm_mc_runner_arm64.cc |   2 +-
 src/gas/llvm_mc_runner_x64.cc   |   2 +-
 src/gas/llvm_mc_runner_x86.cc   |   2 +-
 src/gas/platform.hh             |  28 ++
 src/gas/process.cc              |  35 +-
 src/gas/process.hh              |  22 +-
 src/gas/process.windows.cc      |  15 +-
 18 files changed, 393 insertions(+), 986 deletions(-)
 delete mode 100644 src/compat/getopt.c
 create mode 100644 src/gas/platform.hh

diff --git a/src/compat/getopt.c b/src/compat/getopt.c
deleted file mode 100644
index ac7f9fe..0000000
--- a/src/compat/getopt.c
+++ /dev/null
@@ -1,562 +0,0 @@
-/*	$OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $	*/
-/*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
-
-/*
- * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Sponsored in part by the Defense Advanced Research Projects
- * Agency (DARPA) and Air Force Research Laboratory, Air Force
- * Materiel Command, USAF, under agreement number F39502-99-1-0512.
- */
-/*-
- * Copyright (c) 2000 The NetBSD Foundation, Inc.
- * All rights reserved.
- *
- * This code is derived from software contributed to The NetBSD Foundation
- * by Dieter Baron and Thomas Klausner.
- *
- * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
- */
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <getopt.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <windows.h>
-
-#define	REPLACE_GETOPT		/* use this getopt as the system getopt(3) */
-
-#ifdef REPLACE_GETOPT
-int	opterr = 1;		/* if error message should be printed */
-int	optind = 1;		/* index into parent argv vector */
-int	optopt = '?';		/* character checked for validity */
-#undef	optreset		/* see getopt.h */
-#define	optreset		__mingw_optreset
-int	optreset;		/* reset getopt */
-char    *optarg;		/* argument associated with option */
-#endif
-
-#define PRINT_ERROR	((opterr) && (*options != ':'))
-
-#define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
-#define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
-#define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
-
-/* return values */
-#define	BADCH		(int)'?'
-#define	BADARG		((*options == ':') ? (int)':' : (int)'?')
-#define	INORDER 	(int)1
-
-#ifndef __CYGWIN__
-#define __progname __argv[0]
-#else
-extern char __declspec(dllimport) *__progname;
-#endif
-
-#ifdef __CYGWIN__
-static char EMSG[] = "";
-#else
-#define	EMSG		""
-#endif
-
-static int getopt_internal(int, char * const *, const char *,
-			   const struct option *, int *, int);
-static int parse_long_options(char * const *, const char *,
-			      const struct option *, int *, int);
-static int gcd(int, int);
-static void permute_args(int, int, int, char * const *);
-
-static char *place = EMSG; /* option letter processing */
-
-/* XXX: set optreset to 1 rather than these two */
-static int nonopt_start = -1; /* first non option argument (for permute) */
-static int nonopt_end = -1;   /* first option after non options (for permute) */
-
-/* Error messages */
-static const char recargchar[] = "option requires an argument -- %c";
-static const char recargstring[] = "option requires an argument -- %s";
-static const char ambig[] = "ambiguous option -- %.*s";
-static const char noarg[] = "option doesn't take an argument -- %.*s";
-static const char illoptchar[] = "unknown option -- %c";
-static const char illoptstring[] = "unknown option -- %s";
-
-static void
-_vwarnx(const char *fmt,va_list ap)
-{
-  (void)fprintf(stderr,"%s: ",__progname);
-  if (fmt != NULL)
-    (void)vfprintf(stderr,fmt,ap);
-  (void)fprintf(stderr,"\n");
-}
-
-static void
-warnx(const char *fmt,...)
-{
-  va_list ap;
-  va_start(ap,fmt);
-  _vwarnx(fmt,ap);
-  va_end(ap);
-}
-
-/*
- * Compute the greatest common divisor of a and b.
- */
-static int
-gcd(int a, int b)
-{
-	int c;
-
-	c = a % b;
-	while (c != 0) {
-		a = b;
-		b = c;
-		c = a % b;
-	}
-
-	return (b);
-}
-
-/*
- * Exchange the block from nonopt_start to nonopt_end with the block
- * from nonopt_end to opt_end (keeping the same order of arguments
- * in each block).
- */
-static void
-permute_args(int panonopt_start, int panonopt_end, int opt_end,
-	char * const *nargv)
-{
-	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
-	char *swap;
-
-	/*
-	 * compute lengths of blocks and number and size of cycles
-	 */
-	nnonopts = panonopt_end - panonopt_start;
-	nopts = opt_end - panonopt_end;
-	ncycle = gcd(nnonopts, nopts);
-	cyclelen = (opt_end - panonopt_start) / ncycle;
-
-	for (i = 0; i < ncycle; i++) {
-		cstart = panonopt_end+i;
-		pos = cstart;
-		for (j = 0; j < cyclelen; j++) {
-			if (pos >= panonopt_end)
-				pos -= nnonopts;
-			else
-				pos += nopts;
-			swap = nargv[pos];
-			/* LINTED const cast */
-			((char **) nargv)[pos] = nargv[cstart];
-			/* LINTED const cast */
-			((char **)nargv)[cstart] = swap;
-		}
-	}
-}
-
-/*
- * parse_long_options --
- *	Parse long options in argc/argv argument vector.
- * Returns -1 if short_too is set and the option does not match long_options.
- */
-static int
-parse_long_options(char * const *nargv, const char *options,
-	const struct option *long_options, int *idx, int short_too)
-{
-	char *current_argv, *has_equal;
-	size_t current_argv_len;
-	int i, ambiguous, match;
-
-#define IDENTICAL_INTERPRETATION(_x, _y)                                \
-	(long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
-	 long_options[(_x)].flag == long_options[(_y)].flag &&          \
-	 long_options[(_x)].val == long_options[(_y)].val)
-
-	current_argv = place;
-	match = -1;
-	ambiguous = 0;
-
-	optind++;
-
-	if ((has_equal = strchr(current_argv, '=')) != NULL) {
-		/* argument found (--option=arg) */
-		current_argv_len = has_equal - current_argv;
-		has_equal++;
-	} else
-		current_argv_len = strlen(current_argv);
-
-	for (i = 0; long_options[i].name; i++) {
-		/* find matching long option */
-		if (strncmp(current_argv, long_options[i].name,
-		    current_argv_len))
-			continue;
-
-		if (strlen(long_options[i].name) == current_argv_len) {
-			/* exact match */
-			match = i;
-			ambiguous = 0;
-			break;
-		}
-		/*
-		 * If this is a known short option, don't allow
-		 * a partial match of a single character.
-		 */
-		if (short_too && current_argv_len == 1)
-			continue;
-
-		if (match == -1)	/* partial match */
-			match = i;
-		else if (!IDENTICAL_INTERPRETATION(i, match))
-			ambiguous = 1;
-	}
-	if (ambiguous) {
-		/* ambiguous abbreviation */
-		if (PRINT_ERROR)
-			warnx(ambig, (int)current_argv_len,
-			     current_argv);
-		optopt = 0;
-		return (BADCH);
-	}
-	if (match != -1) {		/* option found */
-		if (long_options[match].has_arg == no_argument
-		    && has_equal) {
-			if (PRINT_ERROR)
-				warnx(noarg, (int)current_argv_len,
-				     current_argv);
-			/*
-			 * XXX: GNU sets optopt to val regardless of flag
-			 */
-			if (long_options[match].flag == NULL)
-				optopt = long_options[match].val;
-			else
-				optopt = 0;
-			return (BADARG);
-		}
-		if (long_options[match].has_arg == required_argument ||
-		    long_options[match].has_arg == optional_argument) {
-			if (has_equal)
-				optarg = has_equal;
-			else if (long_options[match].has_arg ==
-			    required_argument) {
-				/*
-				 * optional argument doesn't use next nargv
-				 */
-				optarg = nargv[optind++];
-			}
-		}
-		if ((long_options[match].has_arg == required_argument)
-		    && (optarg == NULL)) {
-			/*
-			 * Missing argument; leading ':' indicates no error
-			 * should be generated.
-			 */
-			if (PRINT_ERROR)
-				warnx(recargstring,
-				    current_argv);
-			/*
-			 * XXX: GNU sets optopt to val regardless of flag
-			 */
-			if (long_options[match].flag == NULL)
-				optopt = long_options[match].val;
-			else
-				optopt = 0;
-			--optind;
-			return (BADARG);
-		}
-	} else {			/* unknown option */
-		if (short_too) {
-			--optind;
-			return (-1);
-		}
-		if (PRINT_ERROR)
-			warnx(illoptstring, current_argv);
-		optopt = 0;
-		return (BADCH);
-	}
-	if (idx)
-		*idx = match;
-	if (long_options[match].flag) {
-		*long_options[match].flag = long_options[match].val;
-		return (0);
-	} else
-		return (long_options[match].val);
-#undef IDENTICAL_INTERPRETATION
-}
-
-/*
- * getopt_internal --
- *	Parse argc/argv argument vector.  Called by user level routines.
- */
-static int
-getopt_internal(int nargc, char * const *nargv, const char *options,
-	const struct option *long_options, int *idx, int flags)
-{
-	char *oli;				/* option letter list index */
-	int optchar, short_too;
-	static int posixly_correct = -1;
-
-	if (options == NULL)
-		return (-1);
-
-	/*
-	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
-	 * XXX using optreset.  Work around this braindamage.
-	 */
-	if (optind == 0)
-		optind = optreset = 1;
-
-	/*
-	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
-	 * string begins with a '+'.
-	 *
-	 * CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or
-	 *                 optreset != 0 for GNU compatibility.
-	 */
-	if (posixly_correct == -1 || optreset != 0)
-		posixly_correct = (GetEnvironmentVariableW(L"POSIXLY_CORRECT", NULL, 0) != 0);
-	if (*options == '-')
-		flags |= FLAG_ALLARGS;
-	else if (posixly_correct || *options == '+')
-		flags &= ~FLAG_PERMUTE;
-	if (*options == '+' || *options == '-')
-		options++;
-
-	optarg = NULL;
-	if (optreset)
-		nonopt_start = nonopt_end = -1;
-start:
-	if (optreset || !*place) {		/* update scanning pointer */
-		optreset = 0;
-		if (optind >= nargc) {          /* end of argument vector */
-			place = EMSG;
-			if (nonopt_end != -1) {
-				/* do permutation, if we have to */
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				optind -= nonopt_end - nonopt_start;
-			}
-			else if (nonopt_start != -1) {
-				/*
-				 * If we skipped non-options, set optind
-				 * to the first of them.
-				 */
-				optind = nonopt_start;
-			}
-			nonopt_start = nonopt_end = -1;
-			return (-1);
-		}
-		if (*(place = nargv[optind]) != '-' ||
-		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
-			place = EMSG;		/* found non-option */
-			if (flags & FLAG_ALLARGS) {
-				/*
-				 * GNU extension:
-				 * return non-option as argument to option 1
-				 */
-				optarg = nargv[optind++];
-				return (INORDER);
-			}
-			if (!(flags & FLAG_PERMUTE)) {
-				/*
-				 * If no permutation wanted, stop parsing
-				 * at first non-option.
-				 */
-				return (-1);
-			}
-			/* do permutation */
-			if (nonopt_start == -1)
-				nonopt_start = optind;
-			else if (nonopt_end != -1) {
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				nonopt_start = optind -
-				    (nonopt_end - nonopt_start);
-				nonopt_end = -1;
-			}
-			optind++;
-			/* process next argument */
-			goto start;
-		}
-		if (nonopt_start != -1 && nonopt_end == -1)
-			nonopt_end = optind;
-
-		/*
-		 * If we have "-" do nothing, if "--" we are done.
-		 */
-		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
-			optind++;
-			place = EMSG;
-			/*
-			 * We found an option (--), so if we skipped
-			 * non-options, we have to permute.
-			 */
-			if (nonopt_end != -1) {
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				optind -= nonopt_end - nonopt_start;
-			}
-			nonopt_start = nonopt_end = -1;
-			return (-1);
-		}
-	}
-
-	/*
-	 * Check long options if:
-	 *  1) we were passed some
-	 *  2) the arg is not just "-"
-	 *  3) either the arg starts with -- we are getopt_long_only()
-	 */
-	if (long_options != NULL && place != nargv[optind] &&
-	    (*place == '-' || (flags & FLAG_LONGONLY))) {
-		short_too = 0;
-		if (*place == '-')
-			place++;		/* --foo long option */
-		else if (*place != ':' && strchr(options, *place) != NULL)
-			short_too = 1;		/* could be short option too */
-
-		optchar = parse_long_options(nargv, options, long_options,
-		    idx, short_too);
-		if (optchar != -1) {
-			place = EMSG;
-			return (optchar);
-		}
-	}
-
-	if ((optchar = (int)*place++) == (int)':' ||
-	    (optchar == (int)'-' && *place != '\0') ||
-	    (oli = strchr(options, optchar)) == NULL) {
-		/*
-		 * If the user specified "-" and  '-' isn't listed in
-		 * options, return -1 (non-option) as per POSIX.
-		 * Otherwise, it is an unknown option character (or ':').
-		 */
-		if (optchar == (int)'-' && *place == '\0')
-			return (-1);
-		if (!*place)
-			++optind;
-		if (PRINT_ERROR)
-			warnx(illoptchar, optchar);
-		optopt = optchar;
-		return (BADCH);
-	}
-	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
-		/* -W long-option */
-		if (*place)			/* no space */
-			/* NOTHING */;
-		else if (++optind >= nargc) {	/* no arg */
-			place = EMSG;
-			if (PRINT_ERROR)
-				warnx(recargchar, optchar);
-			optopt = optchar;
-			return (BADARG);
-		} else				/* white space */
-			place = nargv[optind];
-		optchar = parse_long_options(nargv, options, long_options,
-		    idx, 0);
-		place = EMSG;
-		return (optchar);
-	}
-	if (*++oli != ':') {			/* doesn't take argument */
-		if (!*place)
-			++optind;
-	} else {				/* takes (optional) argument */
-		optarg = NULL;
-		if (*place)			/* no white space */
-			optarg = place;
-		else if (oli[1] != ':') {	/* arg not optional */
-			if (++optind >= nargc) {	/* no arg */
-				place = EMSG;
-				if (PRINT_ERROR)
-					warnx(recargchar, optchar);
-				optopt = optchar;
-				return (BADARG);
-			} else
-				optarg = nargv[optind];
-		}
-		place = EMSG;
-		++optind;
-	}
-	/* dump back option letter */
-	return (optchar);
-}
-
-#ifdef REPLACE_GETOPT
-/*
- * getopt --
- *	Parse argc/argv argument vector.
- *
- * [eventually this will replace the BSD getopt]
- */
-int
-getopt(int nargc, char * const *nargv, const char *options)
-{
-
-	/*
-	 * We don't pass FLAG_PERMUTE to getopt_internal() since
-	 * the BSD getopt(3) (unlike GNU) has never done this.
-	 *
-	 * Furthermore, since many privileged programs call getopt()
-	 * before dropping privileges it makes sense to keep things
-	 * as simple (and bug-free) as possible.
-	 */
-	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
-}
-#endif /* REPLACE_GETOPT */
-
-/*
- * getopt_long --
- *	Parse argc/argv argument vector.
- */
-int
-getopt_long(int nargc, char * const *nargv, const char *options,
-    const struct option *long_options, int *idx)
-{
-
-	return (getopt_internal(nargc, nargv, options, long_options, idx,
-	    FLAG_PERMUTE));
-}
-
-/*
- * getopt_long_only --
- *	Parse argc/argv argument vector.
- */
-int
-getopt_long_only(int nargc, char * const *nargv, const char *options,
-    const struct option *long_options, int *idx)
-{
-
-	return (getopt_internal(nargc, nargv, options, long_options, idx,
-	    FLAG_PERMUTE|FLAG_LONGONLY));
-}
diff --git a/src/gas/CMakeLists.txt b/src/gas/CMakeLists.txt
index 31aaefc..7cc7d3e 100644
--- a/src/gas/CMakeLists.txt
+++ b/src/gas/CMakeLists.txt
@@ -19,7 +19,6 @@ set(ARCH_PREFIXES
 
 if(WIN32)
   list(APPEND GAS_DRIVER_SOURCES
-    ../compat/getopt.c
     gas.windows.cc
     process.windows.cc
     )
diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 905d106..13e893c 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <iostream>
+#include <optional>
 
 #include "command_line.hh"
 
@@ -10,36 +11,51 @@ namespace ranges = std::ranges;
 
 bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb)
 {
-	stdout() << "Got " << options.size() << " options\n" << "Passed args:\n";
+	STDOUT << "Got " << options.size() << " options\n" << "Passed args:\n";
 
 	uint32_t positional_count = 0;
-	bool next_must_be_positional = false;
+	bool next_arg_is_value = false;
+	std::optional<CommandLineOption> last_opt;
 
 	for (int i = 1; i < argc; i++) {
-		TOptionString option { argv[i] };
+		platform::string option { argv[i] };
 		if (option.empty ()) {
 			continue;
 		}
 
-		stdout() << "  [" << i << "] " << option << "\n";
+		STDOUT << "  [" << i << "] " << option << "\n";
 
-		TOptionString::const_iterator iter = option.cbegin ();
+		platform::string::const_iterator iter = option.cbegin ();
 
 		while (iter != option.cend () && *iter == DASH) {
 			iter++;
 		}
+
+		if (next_arg_is_value) {
+			// getopt takes the next argument verbatim, if separated from the option requiring a value by a space.
+			// This is done regardless of whether or not the next argument is prefixed with `-` or is a known one.
+			if (last_opt.has_value ()) {
+				option_cb (last_opt.value (), option);
+			} else {
+				// TODO: throw, probably
+			}
+
+			next_arg_is_value = false;
+			last_opt.reset ();
+			continue;
+		}
+
 		bool positional = iter == option.cbegin ();
-		stdout() << std::boolalpha << "    Positional? " << positional << "\n";
+		STDOUT << std::boolalpha << "    Positional? " << positional << "\n";
 
-		CommandLineStringView option_name;
-		CommandLineStringView option_value;
+		platform::string_view option_name;
+		platform::string_view option_value;
 		if (positional) {
 			option_cb ({ positional_count++ }, { option });
 			continue;
 		}
 
-		TOptionString::const_iterator name_start = iter;
-
+		platform::string::const_iterator name_start = iter;
 		while (iter != option.cend () && *iter != EQUALS) {
 			iter++;
 		}
@@ -47,15 +63,15 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, T
 		option_name = { name_start, iter };
 
 		bool has_value = iter != option.cend ();
-		stdout() << "    Has value? " << has_value << "\n";
+		STDOUT << "    Has value? " << has_value << "\n";
 
 		if (has_value) {
 			iter++;
 			option_value = { iter, option.cend () };
 		}
 
-		stdout() << "     Option name: " << TOptionString (option_name) << "\n";
-		stdout() << "    Option value: " << TOptionString (option_value) << "\n";
+		STDOUT << "     Option name: " << platform::string (option_name) << "\n";
+		STDOUT << "    Option value: " << platform::string (option_value) << "\n";
 
 		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {
 			if (o.name != option_name) {
@@ -67,10 +83,25 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, T
 
 		auto match = ranges::find_if (options, matching_option);
 		if (match != options.end ()) {
-			stdout() << "    found matching option\n";
+			STDOUT << "    found matching option\n";
 		} else {
-			stderr() << "Uncrecognized option '" << option << "'\n";
+			STDERR << "Uncrecognized option '" << option << "'\n";
+			continue;
+		}
+
+		CommandLineOption opt = *match;
+		if (opt.argument == ArgumentValue::Required && option_value.empty ()) {
+			next_arg_is_value = true;
+			last_opt = opt;
+			continue;
 		}
+
+		option_cb (opt, platform::string {option_value});
+	}
+
+	if (last_opt.has_value ()) {
+		STDERR << "Option '" << last_opt.value ().name << "' requires an argument" << std::endl;
+		return false;
 	}
 
 	return true;
diff --git a/src/gas/command_line.hh b/src/gas/command_line.hh
index 0b79974..a36e192 100644
--- a/src/gas/command_line.hh
+++ b/src/gas/command_line.hh
@@ -15,47 +15,52 @@
 #endif
 
 #include "constants.hh"
+#include "platform.hh"
 
 namespace xamarin::android::gas
 {
-#if !defined (_WIN32)
-	using CommandLineString = std::string;
-	using CommandLineStringView = std::string_view;
-#else
-	using CommandLineString = std::wstring;
-	using CommandLineStringView = std::wstring_view;
-#endif
-
-	enum class Argument
+	enum class ArgumentValue
 	{
 		Required,
 		NotRequired,
 	};
 
+	enum class OptionId : uint32_t
+	{
+		Ignore = 100,
+		O,
+		Warn,
+		G,
+		MFPU,
+		Version,
+		VersionExit,
+		Help,
+	};
+
 	struct CommandLineOption
 	{
-		CommandLineStringView name;
-		uint32_t id;
-		Argument argument;
+		platform::string_view name;
+		OptionId id;
+		ArgumentValue argument;
 		TargetArchitecture arch;
 
-		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, Argument _argument, TargetArchitecture _arch)
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, ArgumentValue _argument, TargetArchitecture _arch)
 			: name (_name),
 			  id (_id),
 			  argument (_argument),
 			  arch (_arch)
 		{}
 
-		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, TargetArchitecture _arch)
-			: CommandLineOption (_name, _id, Argument::NotRequired, _arch)
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, TargetArchitecture _arch)
+			: CommandLineOption (_name, _id, ArgumentValue::NotRequired, _arch)
 		{}
 
-		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id, Argument _argument)
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id, ArgumentValue _argument)
 			: CommandLineOption (_name, _id, _argument, TargetArchitecture::Any)
 		{}
 
-		constexpr CommandLineOption (CommandLineStringView const& _name, uint32_t _id)
-			: CommandLineOption (_name, _id, Argument::NotRequired, TargetArchitecture::Any)
+		constexpr CommandLineOption (platform::string_view const& _name, OptionId _id)
+			: CommandLineOption (_name, _id, ArgumentValue::NotRequired, TargetArchitecture::Any)
 		{}
 	};
 
@@ -70,14 +75,12 @@ namespace xamarin::android::gas
 	public:
 #if !defined(_WIN32)
 		using TArgType = char*;
-		using TOptionString = std::string;
 
 	private:
 		static inline constexpr char DASH = '-';
 		static inline constexpr char EQUALS = '=';
 #else
 		using TArgType = LPWSTR;
-		using TOptionString = std::wstring;
 
 	private:
 		static inline constexpr wchar_t DASH = L'-';
@@ -85,7 +88,7 @@ namespace xamarin::android::gas
 #endif
 
 	public:
-		using TOptionValue = std::variant<bool, TOptionString>;
+		using TOptionValue = std::variant<bool, platform::string>;
 		using TCallbackOption = std::variant<uint32_t, const CommandLineOption>;
 		using OptionCallbackFn = std::function<void(TCallbackOption option, TOptionValue val)>;
 
@@ -103,33 +106,17 @@ namespace xamarin::android::gas
 	private:
 		bool parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb);
 
-		static constexpr auto& stdout () noexcept
-		{
-			if constexpr (is_windows) {
-				return std::wcout;
-			} else {
-				return std::cout;
-			}
-		}
-
-		static constexpr auto& stderr () noexcept
-		{
-			if constexpr (is_windows) {
-				return std::wcerr;
-			} else {
-				return std::cerr;
-			}
-		}
-
 	private:
 		TargetArchitecture target_arch;
 	};
 }
 
+#define CLISTR(_str_lit_) PSTR((_str_lit_))
+
 #if !defined (_WIN32)
-#define CLISTR(_str_lit_) std::string_view { _str_lit_ }
+#define CLIPARAM(_str_lit_) std::string_view { _str_lit_ }
 #else
-#define CLISTR(_str_lit_) std::wstring_view { L##_str_lit_ }
+#define CLIPARAM(_str_lit_) std::wstring_view { L##_str_lit_ }
 #endif
 
 #endif // ndef GAS_COMMAND_LINE_HH
diff --git a/src/gas/constants.hh b/src/gas/constants.hh
index 253bc57..d29db8c 100644
--- a/src/gas/constants.hh
+++ b/src/gas/constants.hh
@@ -2,20 +2,22 @@
 #if !defined (__CONSTANTS_HH)
 #define __CONSTANTS_HH
 
+#include "platform.hh"
+
 namespace xamarin::android::gas
 {
 	class Constants final
 	{
 	public:
 #if defined (_WIN32)
-		static constexpr char newline[] = "\r\n";
-		static constexpr char llvm_mc_name[] = "llvm-mc.exe";
+		static constexpr platform::string_view newline { L"\r\n" };
+		static constexpr platform::string_view llvm_mc_name { L"llvm-mc.exe" };
 #else
-		static constexpr char newline[] = "\n";
-		static constexpr char llvm_mc_name[] = "llvm-mc";
+		static constexpr platform::string_view newline { "\n" };
+		static constexpr platform::string_view llvm_mc_name { "llvm-mc" };
 #endif
-		static constexpr char arch_hack_param[] = "@gas-arch=";
-		static constexpr char default_output_name[] = "a.out";
+		static constexpr platform::string_view arch_hack_param { PSTR("@gas-arch=") };
+		static constexpr platform::string_view default_output_name { PSTR("a.out") };
 		static constexpr int wrapper_general_error_code         = 100;
 		static constexpr int wrapper_llvm_mc_killed_error_code  = wrapper_general_error_code + 1;
 		static constexpr int wrapper_llvm_mc_stopped_error_code = wrapper_general_error_code + 2;
diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index c3b36a5..2a28a3a 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -15,13 +15,13 @@
 
 using namespace xamarin::android::gas;
 
-int Gas::usage (bool is_error, std::string const message)
+int Gas::usage (bool is_error, platform::string const message)
 {
 	if (!message.empty ()) {
-		std::cerr << message << Constants::newline << Constants::newline;
+		STDERR << message << Constants::newline << Constants::newline;
 	}
 
-	std::cerr << "`" << program_name () << "` takes a subset of arguments accepted by the GNU Assembler (gas) program." << Constants::newline
+	STDERR << "`" << program_name () << "` takes a subset of arguments accepted by the GNU Assembler (gas) program." << Constants::newline
 	          << "Accepted options are limited to the ones used by Xamarin.Android and Mono/dotnet AOT, more can be added as-needed." << Constants::newline
 	          << "Some options are accepted but ignored, either because they are ignored by GAS as well or because they are used by" << Constants::newline
 	          << "Xamarin.Android or Mono/dotnet AOT, but not needed by `llvm-mc`.  All the unsupported options will cause the wrapper" << Constants::newline
@@ -58,13 +58,13 @@ int Gas::usage (bool is_error, std::string const message)
 	return is_error ? 1 : 0;
 }
 
-int Gas::run (int argc, char **argv)
+int Gas::run (int argc, CommandLine::TArgType *argv)
 {
-	std::cout << "Gas::run" << std::endl;
+	STDOUT << "Gas::run" << std::endl;
 	determine_program_dir (argc, argv);
-	std::cout << "Program dir determined" << std::endl;
+	STDOUT << "Program dir determined" << std::endl;
 
-	auto lowercase_string = [](std::string& s) {
+	auto lowercase_string = [](platform::string& s) {
 		std::transform (
 			s.begin (),
 			s.end (),
@@ -73,18 +73,18 @@ int Gas::run (int argc, char **argv)
 		);
 	};
 
-	std::cout << "Determining arch name" << std::endl;
-	std::string arch_name { generic_gas_name };
-	const char *first_param = argc > 1 ? argv[1] : nullptr;
-	if (first_param != nullptr && strlen (first_param) > sizeof(Constants::arch_hack_param) && strstr (first_param, Constants::arch_hack_param) == first_param) {
-		arch_name = first_param + (sizeof(Constants::arch_hack_param) - 1);
+	STDOUT << "Determining arch name" << std::endl;
+	platform::string arch_name { generic_gas_name };
+	platform::string first_param { argc > 1 ? argv[1] : PSTR("") };
+	if (!first_param.empty () && first_param.length () > Constants::arch_hack_param.size () && first_param.find (Constants::arch_hack_param) == 0) {
+		arch_name = first_param.substr (Constants::arch_hack_param.size ());
 		lowercase_string (arch_name);
 	}
-	std::cout << "arch_name == " << arch_name << std::endl;
+	STDOUT << "arch_name == " << arch_name << std::endl;
 	_program_name = arch_name;
 
 	std::unique_ptr<LlvmMcRunner> mc_runner;
-	std::string ld_name;
+	platform::string ld_name;
 	if (arch_name.compare (arm64_gas_name.data ()) == 0) {
 		_target_arch = TargetArchitecture::ARM64;
 		mc_runner = std::make_unique<LlvmMcRunnerARM64> ();
@@ -102,38 +102,38 @@ int Gas::run (int argc, char **argv)
 		mc_runner = std::make_unique<LlvmMcRunnerX64> ();
 		ld_name = x64_ld_name.data ();
 	} else if (arch_name.compare (generic_gas_name) == 0) {
-		std::string message { "Program invoked via its generic name (" };
+		platform::string message { PSTR("Program invoked via its generic name (") };
 		message
 			.append (generic_gas_name)
-			.append ("), please use one of the ABI-prefixed names:")
+			.append (PSTR("), please use one of the ABI-prefixed names:"))
 			.append (Constants::newline)
-			.append ("  ").append (arm64_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (arm32_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (x86_gas_name.data ()).append (Constants::newline)
-			.append ("  ").append (x64_gas_name.data ()).append (Constants::newline);
+			.append (PSTR("  ")).append (arm64_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (arm32_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (x86_gas_name.data ()).append (Constants::newline)
+			.append (PSTR("  ")).append (x64_gas_name.data ()).append (Constants::newline);
 		return usage (true /* is_error */, message);
 	} else {
-		std::string message { "Unknown program name '" };
-		message.append (arch_name).append ("'").append (Constants::newline);
+		platform::string message { PSTR("Unknown program name '") };
+		message.append (arch_name).append (PSTR("'")).append (Constants::newline);
 		return usage (true /* is_error */, message);
 	}
 
-	std::cout << "About to parse arguments" << std::endl;
+	STDOUT << "About to parse arguments" << std::endl;
 	auto&& [terminate, is_error] = parse_arguments (argc, argv, mc_runner);
-	std::cout << "Arguments parsed; terminate == " << terminate << "; is_error == " << is_error << std::endl;
+	STDOUT << "Arguments parsed; terminate == " << terminate << "; is_error == " << is_error << std::endl;
 	if (terminate || is_error) {
 		return is_error ? Constants::wrapper_general_error_code : 0;
 	}
 
-	std::cout << "Getting path to llvm_mc" << std::endl;
+	STDOUT << "Getting path to llvm_mc" << std::endl;
 	fs::path llvm_mc = program_dir () / Constants::llvm_mc_name;
-	std::wcout << "llvm_mc == " << llvm_mc.c_str () << std::endl;
+	STDOUT << "llvm_mc == " << llvm_mc.c_str () << std::endl;
 
 	bool multiple_input_files = false;
 	bool derive_output_file_name = false;
 	switch (input_files.size ()) {
 		case 0:
-			return usage (true, "missing input files on command line");
+			return usage (true, PSTR("missing input files on command line"));
 
 		case 1:
 			// We should always have a value here since `a.out` is the default, but... :)
@@ -151,11 +151,11 @@ int Gas::run (int argc, char **argv)
 	}
 
 	for (fs::path const& input : input_files) {
-		std::wcout << "running llvm-mc for '" << input.c_str () << std::endl;
+		STDOUT << "running llvm-mc for '" << input.c_str () << std::endl;
 		mc_runner->set_input_file_path (input, derive_output_file_name);
 		int ret = mc_runner->run (llvm_mc);
 		if (ret != 0) {
-			std::cout << "  mc_runner failed with " << ret << std::endl;
+			STDOUT << "  mc_runner failed with " << ret << std::endl;
 			return ret;
 		}
 	}
@@ -169,14 +169,14 @@ int Gas::run (int argc, char **argv)
 		fs::path ld_path { program_dir () };
 		ld_path /= ld_name;
 		auto ld = std::make_unique<Process> (ld_path);
-		ld->append_program_argument ("-o");
-		ld->append_program_argument (_gas_output_file.empty () ? Constants::default_output_name : _gas_output_file.string ());
-		ld->append_program_argument ("--relocatable");
+		ld->append_program_argument (PSTR("-o"));
+		ld->append_program_argument (_gas_output_file.empty () ? platform::string (Constants::default_output_name) : _gas_output_file.native ());
+		ld->append_program_argument (PSTR("--relocatable"));
 
-		std::cout << "Have multiple output files:" << Constants::newline;
+		STDOUT << "Have multiple output files:" << Constants::newline;
 		for (fs::path const& output : output_files) {
-			std::cout << "  " << output << Constants::newline;
-			ld->append_program_argument (output.string ());
+			STDOUT << "  " << output << Constants::newline;
+			ld->append_program_argument (output.native ());
 		}
 
 		return ld->run ();
@@ -187,72 +187,39 @@ int Gas::run (int argc, char **argv)
 
 constexpr std::array<CommandLineOption, 21> all_options {{
 	// Arguments ignored by GAS, we shall ignore them silently too
-	{ CLISTR("divide"),    OPTION_IGNORE },
-	{ CLISTR("k"),         OPTION_IGNORE },
-	{ CLISTR("nocpp"),     OPTION_IGNORE },
-	{ CLISTR("Qn"),        OPTION_IGNORE },
-	{ CLISTR("Qy"),        OPTION_IGNORE },
-	{ CLISTR("s"),         OPTION_IGNORE },
-	{ CLISTR("w"),         OPTION_IGNORE },
-	{ CLISTR("X"),         OPTION_IGNORE },
+	{ CLIPARAM("divide"),    OptionId::Ignore },
+	{ CLIPARAM("k"),         OptionId::Ignore },
+	{ CLIPARAM("nocpp"),     OptionId::Ignore },
+	{ CLIPARAM("Qn"),        OptionId::Ignore },
+	{ CLIPARAM("Qy"),        OptionId::Ignore },
+	{ CLIPARAM("s"),         OptionId::Ignore },
+	{ CLIPARAM("w"),         OptionId::Ignore },
+	{ CLIPARAM("X"),         OptionId::Ignore },
 
 	// Global GAS arguments we support
-	{ CLISTR("o"),         OPTION_O,              Argument::Required },
-	{ CLISTR("warn"),      OPTION_WARN },
-	{ CLISTR("g"),         OPTION_G },
-	{ CLISTR("gen-debug"), OPTION_G },
+	{ CLIPARAM("o"),         OptionId::O,              ArgumentValue::Required },
+	{ CLIPARAM("warn"),      OptionId::Warn },
+	{ CLIPARAM("g"),         OptionId::G },
+	{ CLIPARAM("gen-debug"), OptionId::G },
 
 	// Arguments handled by us, not passed to llvm-mc
-	{ CLISTR("h"),         OPTION_HELP },
-	{ CLISTR("help"),      OPTION_HELP },
-	{ CLISTR("V"),         OPTION_VERSION },
-	{ CLISTR("version"),   OPTION_VERSION_EXIT },
+	{ CLIPARAM("h"),         OptionId::Help },
+	{ CLIPARAM("help"),      OptionId::Help },
+	{ CLIPARAM("V"),         OptionId::Version },
+	{ CLIPARAM("version"),   OptionId::VersionExit },
 
 	// x86 arguments
-	{ CLISTR("32"),        OPTION_IGNORE,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
-	{ CLISTR("64"),        OPTION_IGNORE,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
+	{ CLIPARAM("32"),        OptionId::Ignore,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
+	{ CLIPARAM("64"),        OptionId::Ignore,         TargetArchitecture::X86 }, // llvm-mc doesn't need this
 
 	// x64 arguments
-	{ CLISTR("32"),        OPTION_IGNORE,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
-	{ CLISTR("64"),        OPTION_IGNORE,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
+	{ CLIPARAM("32"),        OptionId::Ignore,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
+	{ CLIPARAM("64"),        OptionId::Ignore,         TargetArchitecture::X64 }, // llvm-mc doesn't need this
 
 	// Arm32 arguments
-	{ CLISTR("mfpu"),      OPTION_MFPU,           Argument::Required, TargetArchitecture::ARM32 },
+	{ CLIPARAM("mfpu"),      OptionId::MFPU,           ArgumentValue::Required, TargetArchitecture::ARM32 },
 }};
 
-std::vector<option> Gas::common_options {
-	// Arguments ignored by GAS, we shall ignore them silently too
-	{ "divide",    no_argument,       nullptr, OPTION_IGNORE },
-	{ "k",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "nocpp",     no_argument,       nullptr, OPTION_IGNORE },
-	{ "Qn",        no_argument,       nullptr, OPTION_IGNORE },
-	{ "Qy",        no_argument,       nullptr, OPTION_IGNORE },
-	{ "s",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "w",         no_argument,       nullptr, OPTION_IGNORE },
-	{ "X",         no_argument,       nullptr, OPTION_IGNORE },
-
-	// Global GAS arguments we support
-	{ "o",         required_argument, nullptr, OPTION_O },
-	{ "warn",      no_argument,       nullptr, OPTION_WARN },
-	{ "g",         no_argument,       nullptr, OPTION_G },
-	{ "gen-debug", no_argument,       nullptr, OPTION_G },
-
-	// Arguments handled by us, not passed to llvm-mc
-	{ "h",         no_argument,       nullptr, OPTION_HELP },
-	{ "help",      no_argument,       nullptr, OPTION_HELP },
-	{ "V",         no_argument,       nullptr, OPTION_VERSION },
-	{ "version",   no_argument,       nullptr, OPTION_VERSION_EXIT },
-};
-
-std::vector<option> Gas::x86_options {
-	{ "32", no_argument, nullptr, OPTION_IGNORE }, // llvm-mc doesn't need this
-	{ "64", no_argument, nullptr, OPTION_IGNORE }, // llvm-mc doesn't need this
-};
-
-std::vector<option> Gas::arm32_options {
-	{ "mfpu", required_argument, nullptr, OPTION_MFPU },
-};
-
 Gas::ParseArgsResult Gas::parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner)
 {
 	bool terminate = false, is_error = false;
@@ -260,92 +227,77 @@ Gas::ParseArgsResult Gas::parse_arguments (int argc, CommandLine::TArgType *argv
 
 	auto handle_arg = [&](CommandLine::TCallbackOption option, CommandLine::TOptionValue val) {
 		if (std::holds_alternative<uint32_t> (option)) {
+			platform::string arg = std::get<platform::string> (val);
 			// Positional argument
-			std::cout << "Positional argument no. " << std::get<uint32_t> (option) << ": " << std::get<CommandLine::TOptionString> (val) << "\n";
+			STDOUT << "Positional argument no. " << std::get<uint32_t> (option) << ": " << arg << "\n";
+			if (arg.starts_with (Constants::arch_hack_param)) {
+				// Arch hack, ignore
+				STDOUT << "  arch hack param, ignored\n";
+				return;
+			}
+
+			STDOUT << "  input file\n";
+			input_files.emplace_back (arg);
 			return;
 		}
-	};
-
-	CommandLine cmdline { target_arch () };
-	bool valid = cmdline.parse (all_options, argc, argv, handle_arg);
 
-	std::vector<option> long_options { common_options };
-
-	switch (target_arch ()) {
-		case TargetArchitecture::ARM32:
-			long_options.insert (long_options.end (), arm32_options.begin (), arm32_options.end ());
-			break;
-
-		case TargetArchitecture::X86:
-		case TargetArchitecture::X64:
-			long_options.insert (long_options.end (), x86_options.begin (), x86_options.end ());
-			break;
-
-		default:
-			break;
-	}
-	long_options.push_back ({ nullptr, 0, nullptr, 0 });
-
-	constexpr char PROGRAM_DESCRIPTION[] = "Xamarin.Android GAS adapter for llvm-mc";
-
-	while (true) {
-		int opt_index = 0;
-		int c = getopt_long_only (argc, argv, "-", long_options.data (), &opt_index);
-
-		if (c == -1) {
-			break;
+		const auto opt = std::get<const CommandLineOption> (option);
+		STDOUT << "Option argument: " << platform::string (opt.name) << "\n";
+		if (opt.id == OptionId::Ignore) {
+			STDOUT << "  ignored\n";
+			return;
 		}
 
-		switch (c) {
-			case '?':
-				terminate = true;
-				is_error = true;
-				break;
-
-			case 1: // non-option argument
-			{
-				// Ignore the arch hack parameter
-				const char *ret = strstr (optarg, Constants::arch_hack_param);
-				if (ret == nullptr || ret != optarg) {
-					// char8_t* cast treats path string as utf8
-					input_files.emplace_back (reinterpret_cast<char8_t*>(optarg));
-				}
-			}
-			break;
+		if (std::holds_alternative<bool> (val)) {
+			STDOUT << "  boolean\n";
+		} else {
+			STDOUT << "  value: " << std::get<platform::string> (val) << "\n";
+		}
 
-			case OPTION_VERSION:
+		switch (opt.id) {
+			case OptionId::Version:
 				show_version = true;
 				break;
 
-			case OPTION_VERSION_EXIT:
+			case OptionId::VersionExit:
 				show_version = true;
 				terminate = true;
 				break;
 
-			case OPTION_HELP:
+			case OptionId::Help:
 				show_help = true;
 				terminate = true;
 				break;
 
-			case OPTION_O:
-				_gas_output_file = reinterpret_cast<char8_t*>(optarg);
+			case OptionId::O:
+				_gas_output_file = std::get<platform::string> (val);
 				break;
 
-			case OPTION_MFPU:
-				mc_runner->map_option ("mfpu", optarg);
+			case OptionId::MFPU:
+				mc_runner->map_option (PSTR("mfpu"), std::get<platform::string> (val));
 				break;
 
-			case OPTION_G:
+			case OptionId::G:
 				mc_runner->generate_debug_info ();
 				break;
+
+			default:
+				break;
 		}
+	};
+
+	CommandLine cmdline { target_arch () };
+	if (!cmdline.parse (all_options, argc, argv, handle_arg)) {
+		terminate = true;
+		is_error = true;
 	}
 
+	constexpr platform::string_view PROGRAM_DESCRIPTION { PSTR("Xamarin.Android GAS adapter for llvm-mc") };
 	if (show_help) {
 		usage (false /* is_error */);
 		return {true, false};
 	} else if (show_version) {
-		std::cout << program_name () << " v" << XA_UTILS_VERSION << ", " << PROGRAM_DESCRIPTION << Constants::newline
+		STDOUT << program_name () << " v" << XA_UTILS_VERSION << ", " << PROGRAM_DESCRIPTION << Constants::newline
 		          << "\tGAS version compatibility: " << BINUTILS_VERSION << Constants::newline
 		          << "\tllvm-mc version compatibility: " << LLVM_VERSION << Constants::newline << Constants::newline;
 		return {true, false};
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index aac183a..20d6e51 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -8,16 +8,13 @@
 #include <getopt.h>
 
 #include <array>
+#include <concepts>
 #include <filesystem>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <vector>
 
-#if __has_include (<concepts>)
-#include <concepts>
-#endif // has <concepts>
-
 #include "command_line.hh"
 #include "constants.hh"
 
@@ -52,85 +49,37 @@ namespace xamarin::android::gas
 
 	class LlvmMcRunner;
 
-	enum OptionValues
-	{
-		OPTION_IGNORE = 100,
-		OPTION_O,
-		OPTION_WARN,
-		OPTION_G,
-		OPTION_MFPU,
-		OPTION_VERSION,
-		OPTION_VERSION_EXIT,
-		OPTION_HELP,
-	};
-
-	template<size_t Size>
-	struct helper_char_array final
-	{
-		constexpr char* data () noexcept
-		{
-			return _elems;
-		}
-
-		constexpr const char* data () const noexcept
-		{
-			return _elems;
-		}
-
-		constexpr char const& operator[] (size_t n) const noexcept
-		{
-			return _elems[n];
-		}
-
-		constexpr char& operator[] (size_t n) noexcept
-		{
-			return _elems[n];
-		}
-
-		char _elems[Size]{};
-	};
+	template<class T>
+	concept StringViewPart = std::is_same_v<T, platform::string_view>;
 
-	// MinGW 9 on the CI build bots has a bug in the gcc compiler which causes builds to fail with:
-	//
-	//  error G713F753E: ‘constexpr auto xamarin::android::concat_const(const char (&)[Length]...) [with long long unsigned int ...Length = {15, 7, 5}]’ called in a constant expression
-	//  ...
-	//  /usr/lib/gcc/x86_64-w64-mingw32/9.3-win32/include/c++/array:94:12: note: ‘struct std::array<char, 17>’ has no user-provided default constructor
-	// struct array
-	// ^~~~~
-	// /usr/lib/gcc/x86_64-w64-mingw32/9.3-win32/include/c++/array:110:56: note: and the implicitly-defined constructor does not initialize ‘char std::array<char, 17>::_M_elems [17]’
-	//  typename _AT_Type::_Type                         _M_elems;
-	//                                                   ^~~~~~~~
-	//
-	// thus we need to use this workaround here
-	//
-#if defined (__MINGW32__) && __GNUC__ < 10
-	template<size_t Size>
-	using char_array = helper_char_array<Size>;
-#else
-	template<size_t Size>
-	using char_array = std::array<char, Size>;
-#endif
-
-	template<size_t ...Length>
-	static constexpr auto concat_const (const char (&...parts)[Length])
+	template<size_t TotalLength, StringViewPart ...T>
+	consteval auto concat_string_views (T const&... parts)
 	{
-		// `parts` being constant string arrays, Length for each of them includes the trailing NUL byte, thus the
-		// `sizeof... (Length)` part which subtracts the number of template parameters - the amount of NUL bytes so that
-		// we don't waste space.
-		constexpr size_t total_length = (... + Length) - sizeof... (Length);
-		char_array<total_length + 1> ret;
-		ret[total_length] = 0;
+		std::array<platform::string_view::value_type, TotalLength + 1> ret; // lgtm [cpp/paddingbyteinformationdisclosure] the buffer is filled in the loop below
+		ret[TotalLength] = 0;
 
 		size_t i = 0;
-		for (char const* from : {parts...}) {
-			for (; *from != '\0'; i++) {
-				ret[i] = *from++;
+		for (auto const& sv : {parts...}) {
+			for (const char ch : sv) {
+				ret[i] = ch;
+				i++;
 			}
 		}
 
 		return ret;
 	}
 
+	consteval size_t calc_size (platform::string_view const& sv1) noexcept
+	{
+		return sv1.size ();
+	}
+
+	template<StringViewPart ...T>
+	consteval size_t calc_size (platform::string_view const& sv1, T const&... other_svs) noexcept
+	{
+		return sv1.size () + calc_size (other_svs...);
+	}
+
 	class Gas final
 	{
 		struct ParseArgsResult
@@ -144,19 +93,19 @@ namespace xamarin::android::gas
 			{}
 		};
 
-		static constexpr char generic_gas_name[] = "as";
-		static constexpr char generic_ld_name[] =
+		static constexpr platform::string_view generic_gas_name { PSTR("as") };
+		static constexpr platform::string_view generic_ld_name {
 #if defined (_WIN32)
-			"ld.exe"
+			PSTR("ld.exe")
 #else
-			"ld"
+			PSTR("ld")
 #endif
-			;
+		};
 
-		static constexpr char arm64_arch_prefix[] = "aarch64-linux-android-";
-		static constexpr char arm32_arch_prefix[] = "arm-linux-androideabi-";
-		static constexpr char x86_arch_prefix[] = "i686-linux-android-";
-		static constexpr char x64_arch_prefix[] = "x86_64-linux-android-";
+		static constexpr platform::string_view arm64_arch_prefix { PSTR("aarch64-linux-android-") };
+		static constexpr platform::string_view arm32_arch_prefix { PSTR("arm-linux-androideabi-") };
+		static constexpr platform::string_view x86_arch_prefix { PSTR("i686-linux-android-") };
+		static constexpr platform::string_view x64_arch_prefix { PSTR("x86_64-linux-android-") };
 
 	public:
 		~Gas ()
@@ -166,7 +115,7 @@ namespace xamarin::android::gas
 
 		int run (int argc, CommandLine::TArgType *argv);
 
-		const std::string& program_name () const noexcept
+		const platform::string& program_name () const noexcept
 		{
 			return _program_name;
 		}
@@ -185,27 +134,37 @@ namespace xamarin::android::gas
 		ParseArgsResult parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner);
 
 	private:
-		void determine_program_dir (int argc, char **argv);
-		int usage (bool is_error, std::string const message = "");
+		void determine_program_dir (int argc, CommandLine::TArgType *argv);
+		int usage (bool is_error, platform::string const message = PSTR(""));
 
 	private:
-		static constexpr auto arm64_gas_name = concat_const (arm64_arch_prefix, generic_gas_name);
-		static constexpr auto arm32_gas_name = concat_const (arm32_arch_prefix, generic_gas_name);
-		static constexpr auto x86_gas_name   = concat_const (x86_arch_prefix, generic_gas_name);
-		static constexpr auto x64_gas_name   = concat_const (x64_arch_prefix, generic_gas_name);
+		static constexpr size_t arm64_gas_name_size = calc_size (arm64_arch_prefix, generic_gas_name);
+		static constexpr auto arm64_gas_name        = concat_string_views<arm64_gas_name_size> (arm64_arch_prefix, generic_gas_name);
+
+		static constexpr size_t arm32_gas_name_size = calc_size (arm32_arch_prefix, generic_gas_name);
+		static constexpr auto arm32_gas_name        = concat_string_views<arm32_gas_name_size> (arm32_arch_prefix, generic_gas_name);
+
+		static constexpr size_t x86_gas_name_size   = calc_size (x86_arch_prefix, generic_gas_name);
+		static constexpr auto x86_gas_name          = concat_string_views<x86_gas_name_size> (x86_arch_prefix, generic_gas_name);
+
+		static constexpr size_t x64_gas_name_size   = calc_size (x64_arch_prefix, generic_gas_name);
+		static constexpr auto x64_gas_name          = concat_string_views<x64_gas_name_size> (x64_arch_prefix, generic_gas_name);
+
+		static constexpr size_t arm64_ld_name_size  = calc_size (arm64_arch_prefix, generic_ld_name);
+		static constexpr auto arm64_ld_name         = concat_string_views<arm64_ld_name_size> (arm64_arch_prefix, generic_ld_name);
+
+		static constexpr size_t arm32_ld_name_size  = calc_size (arm32_arch_prefix, generic_ld_name);
+		static constexpr auto arm32_ld_name         = concat_string_views<arm32_ld_name_size> (arm32_arch_prefix, generic_ld_name);
 
-		static constexpr auto arm64_ld_name  = concat_const (arm64_arch_prefix, generic_ld_name);
-		static constexpr auto arm32_ld_name  = concat_const (arm32_arch_prefix, generic_ld_name);
-		static constexpr auto x86_ld_name    = concat_const (x86_arch_prefix, generic_ld_name);
-		static constexpr auto x64_ld_name    = concat_const (x64_arch_prefix, generic_ld_name);
+		static constexpr size_t x86_ld_name_size    = calc_size (x86_arch_prefix, generic_ld_name);
+		static constexpr auto x86_ld_name           = concat_string_views<x86_ld_name_size> (x86_arch_prefix, generic_ld_name);
 
-		static std::vector<option> common_options;
-		static std::vector<option> x86_options;
-		static std::vector<option> arm32_options;
+		static constexpr size_t x64_ld_name_size    = calc_size (x64_arch_prefix, generic_ld_name);
+		static constexpr auto x64_ld_name           = concat_string_views<x64_ld_name_size> (x64_arch_prefix, generic_ld_name);
 
 		std::vector<fs::path> input_files;
 
-		std::string         _program_name;
+		platform::string    _program_name;
 		fs::path            _gas_output_file;
 		fs::path            _program_dir;
 		TargetArchitecture  _target_arch;
diff --git a/src/gas/gas.windows.cc b/src/gas/gas.windows.cc
index fcfcf28..6aabbcb 100644
--- a/src/gas/gas.windows.cc
+++ b/src/gas/gas.windows.cc
@@ -40,7 +40,7 @@ void Gas::get_command_line (int &argc, char **&argv)
 	argv [argc] = NULL;
 }
 
-void Gas::determine_program_dir ([[maybe_unused]] int argc, [[maybe_unused]] char **argv)
+void Gas::determine_program_dir ([[maybe_unused]] int argc, [[maybe_unused]] CommandLine::TArgType *argv)
 {
 	TCHAR buffer[MAX_PATH + 1]{};
 	constexpr DWORD bufSize = sizeof(buffer) / sizeof(*buffer);
diff --git a/src/gas/llvm_mc_runner.cc b/src/gas/llvm_mc_runner.cc
index caf1e13..c78988e 100644
--- a/src/gas/llvm_mc_runner.cc
+++ b/src/gas/llvm_mc_runner.cc
@@ -7,6 +7,7 @@
 
 #include "constants.hh"
 #include "llvm_mc_runner.hh"
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
@@ -28,34 +29,34 @@ int LlvmMcRunner::run (fs::path const& executable_path)
 
 	auto opt = arguments.find (LlvmMcArgument::Arch);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--arch", opt->second);
+		process->append_program_argument (PSTR("--arch"), opt->second);
 	}
 
-	process->append_program_argument ("--triple", triple);
-	process->append_program_argument ("--assemble");
+	process->append_program_argument (PSTR("--triple"), triple);
+	process->append_program_argument (PSTR("--assemble"));
 
 	opt = arguments.find (LlvmMcArgument::GenerateDebug);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("-g");
+		process->append_program_argument (PSTR("-g"));
 	}
 
 	opt = arguments.find (LlvmMcArgument::FileType);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--filetype", opt->second);
+		process->append_program_argument (PSTR("--filetype"), opt->second);
 	}
 
 	opt = arguments.find (LlvmMcArgument::Mattr);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("--mattr", opt->second, true /* uses_comma_separated_list */);
+		process->append_program_argument (PSTR("--mattr"), opt->second, true /* uses_comma_separated_list */);
 	}
 
 	opt = arguments.find (LlvmMcArgument::Output);
 	if (opt != arguments.end ()) {
-		process->append_program_argument ("-o", opt->second);
+		process->append_program_argument (PSTR("-o"), opt->second);
 	}
 
-	std::string input_file { "\"" + input_file_path.make_preferred ().string () + "\"" };
-	process->append_program_argument (input_file_path.make_preferred ().string ());
+	platform::string input_file { PSTR("\"") + input_file_path.make_preferred ().native () + PSTR("\"") };
+	process->append_program_argument (input_file_path.make_preferred ().native ());
 
 	return process->run ();
 }
diff --git a/src/gas/llvm_mc_runner.hh b/src/gas/llvm_mc_runner.hh
index b56edec..6db1008 100644
--- a/src/gas/llvm_mc_runner.hh
+++ b/src/gas/llvm_mc_runner.hh
@@ -4,12 +4,12 @@
 
 #include <filesystem>
 #include <functional>
-#include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "exceptions.hh"
 #include "gas.hh"
+#include "platform.hh"
 #include "process.hh"
 
 namespace xamarin::android::gas
@@ -64,12 +64,12 @@ namespace xamarin::android::gas
 		fs::path make_output_file_path (fs::path const& input_file)
 		{
 			fs::path out_path = input_file;
-			return out_path.replace_extension (".o").make_preferred ();
+			return out_path.replace_extension (PSTR(".o")).make_preferred ();
 		}
 
 		void set_output_file_path (fs::path const& file_path)
 		{
-			set_option (LlvmMcArgument::Output, file_path.string ());
+			set_option (LlvmMcArgument::Output, file_path.native ());
 		}
 
 		void add_include_path (fs::path const& include_path)
@@ -78,7 +78,7 @@ namespace xamarin::android::gas
 				return;
 			}
 
-			set_option (LlvmMcArgument::IncludeDir, include_path.string ());
+			set_option (LlvmMcArgument::IncludeDir, include_path.native ());
 		}
 
 		void generate_debug_info ()
@@ -86,50 +86,50 @@ namespace xamarin::android::gas
 			set_option (LlvmMcArgument::GenerateDebug);
 		}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") = 0;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) = 0;
 		int run (fs::path const& executable_path);
 
 	protected:
 		LlvmMcRunner (LlvmMcArchitecture arch)
 		{
-			set_option (LlvmMcArgument::FileType, "obj");
+			set_option (LlvmMcArgument::FileType, PSTR("obj"));
 
-			std::string architecture;
-			std::string triple_prefix;
+			platform::string architecture;
+			platform::string triple_prefix;
 			switch (arch) {
 				case LlvmMcArchitecture::ARM64:
-					triple_prefix = architecture = "aarch64";
+					triple_prefix = architecture = PSTR("aarch64");
 					break;
 
 				case LlvmMcArchitecture::ARM32:
-					triple_prefix = architecture = "arm";
+					triple_prefix = architecture = PSTR("arm");
 					break;
 
 				case LlvmMcArchitecture::X86:
-					triple_prefix = architecture = "x86";
+					triple_prefix = architecture = PSTR("x86");
 					break;
 
 				case LlvmMcArchitecture::X64:
-					architecture = "x86-64";
-					triple_prefix = "x86_64";
+					architecture = PSTR("x86-64");
+					triple_prefix = PSTR("x86_64");
 					break;
 			}
 
 			set_arch (architecture);
-			triple = triple_prefix + "-linux-gnu";
+			triple = triple_prefix + PSTR("-linux-gnu");
 		}
 
-		void set_arch (std::string const& arch)
+		void set_arch (platform::string const& arch)
 		{
 			set_option (LlvmMcArgument::Arch, arch);
 		}
 
-		void set_mcpu (std::string const& cpu)
+		void set_mcpu (platform::string const& cpu)
 		{
 			set_option (LlvmMcArgument::Mcpu, cpu);
 		}
 
-		void set_option (LlvmMcArgument argument, std::string const& value = "")
+		void set_option (LlvmMcArgument argument, platform::string const& value = PSTR(""))
 		{
 			if (argument == LlvmMcArgument::Arch) {
 				if (arguments.find (argument) != arguments.end ()) {
@@ -162,14 +162,14 @@ namespace xamarin::android::gas
 			return iter->second;
 		}
 
-		void append_attribute (std::string const& new_attr)
+		void append_attribute (platform::string const& new_attr)
 		{
 			set_option (LlvmMcArgument::Mattr, new_attr);
 		}
 
-		void append_attributes (std::vector<std::string> const& new_attrs)
+		void append_attributes (std::vector<platform::string> const& new_attrs)
 		{
-			for (std::string const& attr : new_attrs) {
+			for (platform::string const& attr : new_attrs) {
 				append_attribute (attr);
 			}
 		}
@@ -177,7 +177,7 @@ namespace xamarin::android::gas
 	private:
 		std::unordered_map<LlvmMcArgument, Process::process_argument> arguments;
 		fs::path input_file_path;
-		std::string triple;
+		platform::string triple;
 	};
 
 	class LlvmMcRunnerARM64 final : public LlvmMcRunner
@@ -190,7 +190,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerARM64 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 
 	class LlvmMcRunnerARM32 final : public LlvmMcRunner
@@ -200,16 +200,16 @@ namespace xamarin::android::gas
 			: LlvmMcRunner (LlvmMcArchitecture::ARM32)
 		{
 			// We always target ARMv7-a
-			append_attribute ("+armv7-a");
+			append_attribute (PSTR("+armv7-a"));
 		}
 
 		virtual ~LlvmMcRunnerARM32 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 
 	private:
-		static std::unordered_map<std::string, std::vector<std::string>> fpu_type_map;
+		static std::unordered_map<platform::string, std::vector<platform::string>> fpu_type_map;
 	};
 
 	class LlvmMcRunnerX64 final : public LlvmMcRunner
@@ -222,7 +222,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerX64 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 
 	class LlvmMcRunnerX86 final : public LlvmMcRunner
@@ -235,7 +235,7 @@ namespace xamarin::android::gas
 		virtual ~LlvmMcRunnerX86 ()
 		{}
 
-		virtual void map_option (std::string const& gas_name, std::string const& value = "") override final;
+		virtual void map_option (platform::string const& gas_name, platform::string const& value = PSTR("")) override final;
 	};
 }
 #endif // __LLVM_MC_RUNNER_HH
diff --git a/src/gas/llvm_mc_runner_arm32.cc b/src/gas/llvm_mc_runner_arm32.cc
index 3c67ed6..fc10a36 100644
--- a/src/gas/llvm_mc_runner_arm32.cc
+++ b/src/gas/llvm_mc_runner_arm32.cc
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: MIT
+#include "command_line.hh"
 #include "exceptions.hh"
 #include "llvm_mc_runner.hh"
 
@@ -14,53 +15,53 @@ using namespace xamarin::android::gas;
 //
 //   llvm-mc --arch=arm --mattr=help < /dev/null
 //
-std::unordered_map<std::string, std::vector<std::string>> LlvmMcRunnerARM32::fpu_type_map {
-	{ "arm1020e",               {}},
-	{ "arm1020t",               {}},
-	{ "arm1136jf-s",            {}},
-	{ "arm7500fe",              {}},
-	{ "crypto-neon-fp-armv8",   {"+crypto", "+neon", "+armv8-a"}},
-	{ "crypto-neon-fp-armv8.1", {"+crypto", "+neon", "+armv8.1-a"}},
-	{ "fp-armv8",               {"+armv8-a"}},
-	{ "fpa",                    {}},
-	{ "fpa10",                  {}},
-	{ "fpa11",                  {}},
-	{ "fpe",                    {}},
-	{ "fpe2",                   {}},
-	{ "fpe3",                   {}},
-	{ "fpv4-sp-d16",            {}},
-	{ "fpv5-d16",               {}},
-	{ "fpv5-sp-d16",            {}},
-	{ "maverick",               {}},
-	{ "neon",                   {"+neon"}},
-	{ "neon-fp-armv8",          {"+neon", "+armv8-a", "+fp-armv8"}},
-	{ "neon-fp-armv8.1",        {"+neon", "+armv8.1-a", "+fp-armv8"}},
-	{ "neon-fp16",              {"+neon", "+fp16"}},
-	{ "neon-vfpv3",             {"+neon", "+vfp3"}},
-	{ "neon-vfpv4",             {"+neon", "+vfp4"}},
-	{ "softfpa",                {"+soft-float"}},
-	{ "softvfp",                {}}, // no llvm-mc equivalent?
-	{ "softvfp+vfp",            {}}, // no llvm-mc equivalent?
-	{ "vfp",                    {}}, // no llvm-mc equivalent?
-	{ "vfp10",                  {}}, // no llvm-mc equivalent?
-	{ "vfp10-r0",               {}}, // no llvm-mc equivalent?
-	{ "vfp9",                   {}}, // no llvm-mc equivalent?
-	{ "vfpv2",                  {"+vfp2"}},
-	{ "vfpv3",                  {"+vfp3"}},
-	{ "vfp3",                   {"+vfp3"}}, // undocumented GAS option, alias for vfpv3 above
-	{ "vfpv3-d16",              {"+vfp3d16"}},
-	{ "vfpv3-d16-fp16",         {"vfp3d16,+fp16"}},
-	{ "vfpv3-fp16",             {"+vfp3,+fp16"}},
-	{ "vfpv3xd",                {}}, // no llvm-mc equivalent?
-	{ "vfpv3xd-d16",            {}}, // no llvm-mc equivalent?
-	{ "vfpv4",                  {"+vfp4"}},
-	{ "vfpv4-d16",              {"+vfp4d16"}},
-	{ "vfpxd",                  {}}, // no llvm-mc equivalent?
+std::unordered_map<platform::string, std::vector<platform::string>> LlvmMcRunnerARM32::fpu_type_map {
+	{ PSTR("arm1020e"),               {}},
+	{ PSTR("arm1020t"),               {}},
+	{ PSTR("arm1136jf-s"),            {}},
+	{ PSTR("arm7500fe"),              {}},
+	{ PSTR("crypto-neon-fp-armv8"),   {PSTR("+crypto"), PSTR("+neon"), PSTR("+armv8-a")}},
+	{ PSTR("crypto-neon-fp-armv8.1"), {PSTR("+crypto"), PSTR("+neon"), PSTR("+armv8.1-a")}},
+	{ PSTR("fp-armv8"),               {PSTR("+armv8-a")}},
+	{ PSTR("fpa"),                    {}},
+	{ PSTR("fpa10"),                  {}},
+	{ PSTR("fpa11"),                  {}},
+	{ PSTR("fpe"),                    {}},
+	{ PSTR("fpe2"),                   {}},
+	{ PSTR("fpe3"),                   {}},
+	{ PSTR("fpv4-sp-d16"),            {}},
+	{ PSTR("fpv5-d16"),               {}},
+	{ PSTR("fpv5-sp-d16"),            {}},
+	{ PSTR("maverick"),               {}},
+	{ PSTR("neon"),                   {PSTR("+neon")}},
+	{ PSTR("neon-fp-armv8"),          {PSTR("+neon"), PSTR("+armv8-a"), PSTR("+fp-armv8")}},
+	{ PSTR("neon-fp-armv8.1"),        {PSTR("+neon"), PSTR("+armv8.1-a"), PSTR("+fp-armv8")}},
+	{ PSTR("neon-fp16"),              {PSTR("+neon"), PSTR("+fp16")}},
+	{ PSTR("neon-vfpv3"),             {PSTR("+neon"), PSTR("+vfp3")}},
+	{ PSTR("neon-vfpv4"),             {PSTR("+neon"), PSTR("+vfp4")}},
+	{ PSTR("softfpa"),                {PSTR("+soft-float")}},
+	{ PSTR("softvfp"),                {}}, // no llvm-mc equivalent?
+	{ PSTR("softvfp+vfp"),            {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp"),                    {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp10"),                  {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp10-r0"),               {}}, // no llvm-mc equivalent?
+	{ PSTR("vfp9"),                   {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv2"),                  {PSTR("+vfp2")}},
+	{ PSTR("vfpv3"),                  {PSTR("+vfp3")}},
+	{ PSTR("vfp3"),                   {PSTR("+vfp3")}}, // undocumented GAS option, alias for vfpv3 above
+	{ PSTR("vfpv3-d16"),              {PSTR("+vfp3d16")}},
+	{ PSTR("vfpv3-d16-fp16"),         {PSTR("vfp3d16,+fp16")}},
+	{ PSTR("vfpv3-fp16"),             {PSTR("+vfp3,+fp16")}},
+	{ PSTR("vfpv3xd"),                {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv3xd-d16"),            {}}, // no llvm-mc equivalent?
+	{ PSTR("vfpv4"),                  {PSTR("+vfp4")}},
+	{ PSTR("vfpv4-d16"),              {PSTR("+vfp4d16")}},
+	{ PSTR("vfpxd"),                  {}}, // no llvm-mc equivalent?
 };
 
-void LlvmMcRunnerARM32::map_option (std::string const& gas_name, std::string const& value)
+void LlvmMcRunnerARM32::map_option (platform::string const& gas_name, platform::string const& value)
 {
-	if (gas_name != "mfpu") {
+	if (gas_name != PSTR("mfpu")) {
 		return;
 	}
 
@@ -70,11 +71,16 @@ void LlvmMcRunnerARM32::map_option (std::string const& gas_name, std::string con
 
 	auto mc_fpu = fpu_type_map.find (value);
 	if (mc_fpu == fpu_type_map.end ()) {
-		throw invalid_argument_error { "Unknown GAS FPU type: " + value };
+		platform::string message { PSTR("Unknown GAS FPU type: ") };
+		message.append (value);
+		throw invalid_argument_error { message };
 	}
 
 	if (mc_fpu->second.empty ()) {
-		throw invalid_operation_error {"Unable to map known GAS FPU type '" + value + "' to llvm-mc value" };
+		platform::string message { PSTR("Unable to map known GAS FPU type '") };
+		message.append (value);
+		message.append (PSTR("' to llvm-mc value"));
+		throw invalid_operation_error { message };
 	}
 
 	append_attributes (mc_fpu->second);
diff --git a/src/gas/llvm_mc_runner_arm64.cc b/src/gas/llvm_mc_runner_arm64.cc
index 793434e..5df5b00 100644
--- a/src/gas/llvm_mc_runner_arm64.cc
+++ b/src/gas/llvm_mc_runner_arm64.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerARM64::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerARM64::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/llvm_mc_runner_x64.cc b/src/gas/llvm_mc_runner_x64.cc
index e7d7293..58a415a 100644
--- a/src/gas/llvm_mc_runner_x64.cc
+++ b/src/gas/llvm_mc_runner_x64.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerX64::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerX64::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/llvm_mc_runner_x86.cc b/src/gas/llvm_mc_runner_x86.cc
index 1120b49..d406938 100644
--- a/src/gas/llvm_mc_runner_x86.cc
+++ b/src/gas/llvm_mc_runner_x86.cc
@@ -3,5 +3,5 @@
 
 using namespace xamarin::android::gas;
 
-void LlvmMcRunnerX86::map_option ([[maybe_unused]] std::string const& gas_name, [[maybe_unused]] std::string const& value)
+void LlvmMcRunnerX86::map_option ([[maybe_unused]] platform::string const& gas_name, [[maybe_unused]] platform::string const& value)
 {}
diff --git a/src/gas/platform.hh b/src/gas/platform.hh
new file mode 100644
index 0000000..7a89183
--- /dev/null
+++ b/src/gas/platform.hh
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+#if !defined(GAS_PLATFORM_HH)
+#define GAS_PLATFORM_HH
+
+#include <string>
+#include <iostream>
+
+#if defined(_WIN32)
+#define STDOUT std::wcout
+#define STDERR std::wcerr
+#define PSTR(_str_lit_) (L##_str_lit_)
+#else
+#define STDOUT std::cout
+#define STDERR std::cerr
+#define PSTR(_str_lit_) (_str_lit_)
+#endif
+
+namespace platform {
+#if !defined (_WIN32)
+	using string = std::string;
+	using string_view = std::string_view;
+#else
+	using string = std::wstring;
+	using string_view = std::wstring_view;
+#endif
+}
+
+#endif // ndef GAS_PLATFORM_HH
diff --git a/src/gas/process.cc b/src/gas/process.cc
index c57e952..ca5b365 100644
--- a/src/gas/process.cc
+++ b/src/gas/process.cc
@@ -2,22 +2,23 @@
 #include <cstring>
 #include <iostream>
 
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
 
 void Process::print_process_command_line ()
 {
-	std::cout << "Running: " << executable_path;
-	for (std::string const& arg : _args) {
-		std::cout << " " << arg;
+	STDOUT << "Running: " << executable_path;
+	for (platform::string const& arg : _args) {
+		STDOUT << " " << arg;
 	}
-	std::cout << "\n";
+	STDOUT << "\n";
 }
 
-std::vector<std::string::const_pointer> Process::make_exec_args ()
+std::vector<platform::string::const_pointer> Process::make_exec_args ()
 {
-	std::vector<std::string::const_pointer> exec_args;
+	std::vector<platform::string::const_pointer> exec_args;
 
 	const char *const epath = executable_path.string ().c_str ();
 	exec_args.push_back (
@@ -27,28 +28,28 @@ std::vector<std::string::const_pointer> Process::make_exec_args ()
 		strdup (epath)
 #endif
 	);
-	for (std::string const& arg : _args) {
+	for (platform::string const& arg : _args) {
 		exec_args.push_back (arg.c_str ());
 	}
 
 	return exec_args;
 }
 
-void Process::append_program_argument (std::string const& option_name, std::string const& option_value)
+void Process::append_program_argument (platform::string const& option_name, platform::string const& option_value)
 {
 	if (option_value.empty ()) {
 		_args.push_back (option_name);
 		return;
 	}
 
-	std::string value_arg { option_name };
-	value_arg.append ("=");
+	platform::string value_arg { option_name };
+	value_arg.append (PSTR("="));
 	value_arg.append (option_value);
 
 	_args.push_back (value_arg);
 }
 
-void Process::append_program_argument (std::string const& option_name, string_list const& option_value, bool uses_comma_separated_list)
+void Process::append_program_argument (platform::string const& option_name, string_list const& option_value, bool uses_comma_separated_list)
 {
 	if (option_value.empty ()) {
 		append_program_argument (option_name);
@@ -56,19 +57,19 @@ void Process::append_program_argument (std::string const& option_name, string_li
 	}
 
 	if (!uses_comma_separated_list) {
-		for (std::string const& value : option_value) {
+		for (platform::string const& value : option_value) {
 			append_program_argument (option_name, value);
 		}
 		return;
 	}
 
-	std::string value_arg { option_name };
-	value_arg.append ("=");
+	platform::string value_arg { option_name };
+	value_arg.append (PSTR("="));
 
-	std::string value_list;
-	for (std::string const& value : option_value) {
+	platform::string value_list;
+	for (platform::string const& value : option_value) {
 		if (!value_list.empty ()) {
-			value_list.append (",");
+			value_list.append (PSTR(","));
 		}
 		value_list.append (value);
 	}
diff --git a/src/gas/process.hh b/src/gas/process.hh
index 6f57475..4520af9 100644
--- a/src/gas/process.hh
+++ b/src/gas/process.hh
@@ -6,15 +6,18 @@
 #include <string>
 #include <variant>
 #include <vector>
+
+#include "command_line.hh"
 #include "gas.hh"
+#include "platform.hh"
 
 namespace xamarin::android::gas
 {
 	class Process
 	{
 	public:
-		using string_list = std::vector<std::string>;
-		using process_argument = std::variant<std::string, string_list>;
+		using string_list = std::vector<platform::string>;
+		using process_argument = std::variant<platform::string, string_list>;
 
 	public:
 		explicit Process (fs::path const& executable_path)
@@ -22,14 +25,13 @@ namespace xamarin::android::gas
 		{}
 
 		int run (bool print_command_line = true);
-		void append_program_argument (std::string const& option_name, std::string const& option_value = "");
-		void append_program_argument (std::string const& option_name, string_list const& option_value, bool uses_comma_separated_list = false);
-
-		void append_program_argument (std::string const& option_name, process_argument const& option_value, bool uses_comma_separated_list = false)
+		void append_program_argument (platform::string const& option_name, platform::string const& option_value = PSTR(""));
+		void append_program_argument (platform::string const& option_name, string_list const& option_value, bool uses_comma_separated_list = false);
+		void append_program_argument (platform::string const& option_name, process_argument const& option_value, bool uses_comma_separated_list = false)
 		{
 			switch (option_value.index ()) {
 				case 0:
-					append_program_argument (option_name, std::get<std::string> (option_value));
+					append_program_argument (option_name, std::get<platform::string> (option_value));
 					break;
 
 				case 1:
@@ -38,17 +40,17 @@ namespace xamarin::android::gas
 			}
 		}
 
-		std::vector<std::string> const& args () const noexcept
+		std::vector<platform::string> const& args () const noexcept
 		{
 			return _args;
 		}
 
 	private:
 		void print_process_command_line ();
-		std::vector<std::string::const_pointer> make_exec_args ();
+		std::vector<platform::string::const_pointer> make_exec_args ();
 
 	private:
-		std::vector<std::string> _args;
+		std::vector<platform::string> _args;
 		fs::path const executable_path;
 	};
 }
diff --git a/src/gas/process.windows.cc b/src/gas/process.windows.cc
index a381d0d..43724ec 100644
--- a/src/gas/process.windows.cc
+++ b/src/gas/process.windows.cc
@@ -6,15 +6,16 @@
 #include <iostream>
 
 #include "constants.hh"
+#include "platform.hh"
 #include "process.hh"
 
 using namespace xamarin::android::gas;
 
-static std::string escape_argument (std::string arg)
+static platform::string escape_argument (platform::string arg)
 {
 	bool needs_quote = false;
 
-	for (std::string::value_type const& c : arg) {
+	for (platform::string::value_type const& c : arg) {
 		if (isalpha (c) || isdigit (c) ||
 		    c == '.' || c == '_' || c == '-' ||
 		    c == '+' || c == '/') {
@@ -29,8 +30,8 @@ static std::string escape_argument (std::string arg)
 		return arg;
 	}
 
-	std::string result = "\"";
-	for (std::string::const_reference c : arg) {
+	platform::string result = "\"";
+	for (platform::string::const_reference c : arg) {
 		if (c == '\"' || c == '\\') {
 			result.append ("\\");
 		}
@@ -48,9 +49,9 @@ int Process::run (bool print_command_line)
 		print_process_command_line ();
 	}
 
-	std::string binary = executable_path.string ();
-	std::string args { escape_argument (binary) };
-	for (std::string const& a : _args) {
+	platform::string binary = executable_path.string ();
+	platform::string args { escape_argument (binary) };
+	for (platform::string const& a : _args) {
 		if (a.empty ()) {
 			continue;
 		}

From 90de45010a7d36ecb7b5ba1d55d0579d5bbf1d05 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Mon, 25 Mar 2024 18:06:46 +0100
Subject: [PATCH 04/11] Builds, but fails to work properly

wide string conversion is... broken. Wide characters and wide strings
are evil
---
 src/CMakeLists.txt              |  2 ++
 src/gas/command_line.cc         |  6 ++---
 src/gas/command_line.hh         |  6 ++---
 src/gas/gas.cc                  | 14 +++++-----
 src/gas/gas.hh                  | 11 ++++----
 src/gas/gas.posix.cc            | 20 +++++++++++---
 src/gas/gas.windows.cc          | 46 ++++++++++++++++-----------------
 src/gas/llvm_mc_runner_arm32.cc | 29 +++++++++++++++++----
 src/gas/main.cc                 | 10 ++++---
 src/gas/process.cc              | 21 +--------------
 src/gas/process.posix.cc        | 19 ++++++++++++++
 src/gas/process.windows.cc      | 32 +++++++++++------------
 12 files changed, 126 insertions(+), 90 deletions(-)

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 868a581..d267897 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -144,6 +144,7 @@ else() # UNIX
     /guard:cf
     /Zi
     /W3
+    /utf-8
   )
 
   set(COMMON_LINKER_ARGS
@@ -213,6 +214,7 @@ add_link_options("$<$<COMPILE_LANGUAGE:CXX>:${XA_UTILS_CXX_LINKER_FLAGS}>")
 add_link_options("$<$<COMPILE_LANGUAGE:C>:${XA_UTILS_C_LINKER_FLAGS}>")
 
 if(WIN32)
+  add_compile_definitions(_UNICODE)
   include_directories(compat)
 endif()
 
diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 13e893c..e2828f4 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -9,7 +9,7 @@
 using namespace xamarin::android::gas;
 namespace ranges = std::ranges;
 
-bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb)
+bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector<platform::string> &args, OptionCallbackFn option_cb)
 {
 	STDOUT << "Got " << options.size() << " options\n" << "Passed args:\n";
 
@@ -17,8 +17,8 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, int argc, T
 	bool next_arg_is_value = false;
 	std::optional<CommandLineOption> last_opt;
 
-	for (int i = 1; i < argc; i++) {
-		platform::string option { argv[i] };
+	for (size_t i = 1; i < args.size (); i++) {
+		platform::string &option = args[i];
 		if (option.empty ()) {
 			continue;
 		}
diff --git a/src/gas/command_line.hh b/src/gas/command_line.hh
index a36e192..a5ea73a 100644
--- a/src/gas/command_line.hh
+++ b/src/gas/command_line.hh
@@ -98,13 +98,13 @@ namespace xamarin::android::gas
 		{}
 
 		template<size_t NElem>
-		bool parse (std::array<CommandLineOption, NElem> const& options, int argc, TArgType *argv, OptionCallbackFn option_cb)
+		bool parse (std::array<CommandLineOption, NElem> const& options, std::vector<platform::string> &args, OptionCallbackFn option_cb)
 		{
-			return parse (std::span (options.data(), options.size()), argc, argv, option_cb);
+			return parse (std::span (options.data(), options.size()), args, option_cb);
 		}
 
 	private:
-		bool parse (std::span<const CommandLineOption> options, int argc, TArgType *argv, OptionCallbackFn option_cb);
+		bool parse (std::span<const CommandLineOption> options, std::vector<platform::string> &args, OptionCallbackFn option_cb);
 
 	private:
 		TargetArchitecture target_arch;
diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index 2a28a3a..c4c856c 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -58,10 +58,10 @@ int Gas::usage (bool is_error, platform::string const message)
 	return is_error ? 1 : 0;
 }
 
-int Gas::run (int argc, CommandLine::TArgType *argv)
+int Gas::run (std::vector<platform::string> args)
 {
 	STDOUT << "Gas::run" << std::endl;
-	determine_program_dir (argc, argv);
+	determine_program_dir (args);
 	STDOUT << "Program dir determined" << std::endl;
 
 	auto lowercase_string = [](platform::string& s) {
@@ -69,13 +69,13 @@ int Gas::run (int argc, CommandLine::TArgType *argv)
 			s.begin (),
 			s.end (),
 			s.begin (),
-			[](unsigned char c) { return std::tolower(c); }
+			[](platform::string::value_type c) { return std::tolower(c); }
 		);
 	};
 
 	STDOUT << "Determining arch name" << std::endl;
 	platform::string arch_name { generic_gas_name };
-	platform::string first_param { argc > 1 ? argv[1] : PSTR("") };
+	platform::string first_param { args.size () > 1 ? args[1] : PSTR("") };
 	if (!first_param.empty () && first_param.length () > Constants::arch_hack_param.size () && first_param.find (Constants::arch_hack_param) == 0) {
 		arch_name = first_param.substr (Constants::arch_hack_param.size ());
 		lowercase_string (arch_name);
@@ -119,7 +119,7 @@ int Gas::run (int argc, CommandLine::TArgType *argv)
 	}
 
 	STDOUT << "About to parse arguments" << std::endl;
-	auto&& [terminate, is_error] = parse_arguments (argc, argv, mc_runner);
+	auto&& [terminate, is_error] = parse_arguments (args, mc_runner);
 	STDOUT << "Arguments parsed; terminate == " << terminate << "; is_error == " << is_error << std::endl;
 	if (terminate || is_error) {
 		return is_error ? Constants::wrapper_general_error_code : 0;
@@ -220,7 +220,7 @@ constexpr std::array<CommandLineOption, 21> all_options {{
 	{ CLIPARAM("mfpu"),      OptionId::MFPU,           ArgumentValue::Required, TargetArchitecture::ARM32 },
 }};
 
-Gas::ParseArgsResult Gas::parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner)
+Gas::ParseArgsResult Gas::parse_arguments (std::vector<platform::string> &args, std::unique_ptr<LlvmMcRunner>& mc_runner)
 {
 	bool terminate = false, is_error = false;
 	bool show_version = false, show_help = false;
@@ -287,7 +287,7 @@ Gas::ParseArgsResult Gas::parse_arguments (int argc, CommandLine::TArgType *argv
 	};
 
 	CommandLine cmdline { target_arch () };
-	if (!cmdline.parse (all_options, argc, argv, handle_arg)) {
+	if (!cmdline.parse (all_options, args, handle_arg)) {
 		terminate = true;
 		is_error = true;
 	}
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index 20d6e51..26e9ae2 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -17,6 +17,7 @@
 
 #include "command_line.hh"
 #include "constants.hh"
+#include "platform.hh"
 
 namespace xamarin::android::gas
 {
@@ -60,7 +61,7 @@ namespace xamarin::android::gas
 
 		size_t i = 0;
 		for (auto const& sv : {parts...}) {
-			for (const char ch : sv) {
+			for (platform::string_view::value_type ch : sv) {
 				ret[i] = ch;
 				i++;
 			}
@@ -111,9 +112,9 @@ namespace xamarin::android::gas
 		~Gas ()
 		{}
 
-		void get_command_line (int &argc, char **&argv);
+		std::vector<platform::string> get_command_line (int &argc, char **&argv);
 
-		int run (int argc, CommandLine::TArgType *argv);
+		int run (std::vector<platform::string> args);
 
 		const platform::string& program_name () const noexcept
 		{
@@ -131,10 +132,10 @@ namespace xamarin::android::gas
 		}
 
 	protected:
-		ParseArgsResult parse_arguments (int argc, CommandLine::TArgType *argv, std::unique_ptr<LlvmMcRunner>& mc_runner);
+		ParseArgsResult parse_arguments (std::vector<platform::string> &args, std::unique_ptr<LlvmMcRunner>& mc_runner);
 
 	private:
-		void determine_program_dir (int argc, CommandLine::TArgType *argv);
+		void determine_program_dir (std::vector<platform::string> args);
 		int usage (bool is_error, platform::string const message = PSTR(""));
 
 	private:
diff --git a/src/gas/gas.posix.cc b/src/gas/gas.posix.cc
index 5481bf6..8a667d9 100644
--- a/src/gas/gas.posix.cc
+++ b/src/gas/gas.posix.cc
@@ -1,18 +1,30 @@
 // SPDX-License-Identifier: MIT
-#include <libgen.h>
+
 #include <cstring>
+#include <vector>
+
+#include <libgen.h>
 
 #include "gas.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
-void Gas::get_command_line ([[maybe_unused]] int &argc, [[maybe_unused]] char **&argv)
+std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
 {
+	std::vector<platform::string> ret;
+
+	for (int i = 0; i < argc; i++) {
+		ret.emplace_back (argv[i]);
+	}
+
+	return ret;
 }
 
-void Gas::determine_program_dir ([[maybe_unused]] int argc, char **argv)
+void Gas::determine_program_dir (std::vector<platform::string> args)
 {
-	fs::path program_path { argv[0] };
+	STDOUT << args[0] << std::endl;
+	fs::path program_path { args[0] };
 
 	_program_name = program_path.filename ();
 	if (program_path.is_absolute ()) {
diff --git a/src/gas/gas.windows.cc b/src/gas/gas.windows.cc
index 6aabbcb..d7a63e2 100644
--- a/src/gas/gas.windows.cc
+++ b/src/gas/gas.windows.cc
@@ -4,43 +4,43 @@
 
 #include <cstring>
 #include <iostream>
+#include <vector>
 
 #include "exceptions.hh"
 #include "gas.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
-void Gas::get_command_line (int &argc, char **&argv)
+std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
 {
-	LPWSTR *argvw = CommandLineToArgvW (GetCommandLineW (), &argc);
-	argv = new char*[argc + 1];
-	memset (argv, 0, argc * sizeof(char*));
 	for (int i = 0; i < argc; i++) {
-		std::cout << "Argument " << i << std::endl;
-		int size = WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, NULL, 0, NULL, NULL);
-		std::cout << "  size: " << size << std::endl;
-		if (size <= 0) {
-			// An error, but we ignore it and try to get the other arguments converted.
-			argv[i] = _strdup ("");
-			continue;
-		}
-
-		argv [i] = new char [size];
-		memset (argv [i], 0, size * sizeof(char));
-		std::cout << "  copying" << std::endl;
-		WideCharToMultiByte (CP_UTF8, 0, argvw [i], -1, argv [i], size, NULL, NULL);
-		std::cout << "  copied" << std::endl;
+		std::printf ("[A][%d] %s\n", i, argv[i]);
 	}
 
-	std::cout << "Processed arguments: " << std::endl;
-	for (int i = 0; i < argc; i++) {
-		std::cout << "  [" << i << "] " << argv[i] << std::endl;
+	LPWSTR *szArglist;
+	int nArgs;
+	int i;
+
+	szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
+	if( NULL == szArglist ) {
+		wprintf(L"CommandLineToArgvW failed\n");
+		return {};
+	} else for( i=0; i<nArgs; i++) printf("[W] %d: %ws\n", i, szArglist[i]);
+
+	int n_args;
+	LPWSTR *argv_wide = CommandLineToArgvW (GetCommandLineW (), &n_args);
+	std::vector<platform::string> ret;
+
+	for (int i = 0; i < n_args; i++) {
+		std::printf ("[W][%d] %ws\n", i, argv_wide[i]);
+		ret.emplace_back (argv_wide[i]);
 	}
 
-	argv [argc] = NULL;
+	return ret;
 }
 
-void Gas::determine_program_dir ([[maybe_unused]] int argc, [[maybe_unused]] CommandLine::TArgType *argv)
+void Gas::determine_program_dir (std::vector<platform::string> args)
 {
 	TCHAR buffer[MAX_PATH + 1]{};
 	constexpr DWORD bufSize = sizeof(buffer) / sizeof(*buffer);
diff --git a/src/gas/llvm_mc_runner_arm32.cc b/src/gas/llvm_mc_runner_arm32.cc
index fc10a36..f79f57b 100644
--- a/src/gas/llvm_mc_runner_arm32.cc
+++ b/src/gas/llvm_mc_runner_arm32.cc
@@ -1,4 +1,7 @@
 // SPDX-License-Identifier: MIT
+
+#include <locale>
+
 #include "command_line.hh"
 #include "exceptions.hh"
 #include "llvm_mc_runner.hh"
@@ -69,17 +72,33 @@ void LlvmMcRunnerARM32::map_option (platform::string const& gas_name, platform::
 		throw invalid_argument_error { "The `-mfpu` option requires a value, argument `value` must not be empty" };
 	}
 
+	auto to_utf8 = [](platform::string const& s) -> std::string {
+#if !defined(_WIN32)
+		return s;
+#else
+		std::string ret (s.length (), 0);
+		std::transform (
+			s.begin (),
+			s.end (),
+			ret.begin (),
+			[](platform::string::value_type ch) {
+				return static_cast<std::string::value_type>(ch); }
+		);
+		return ret;
+#endif
+	};
+
 	auto mc_fpu = fpu_type_map.find (value);
 	if (mc_fpu == fpu_type_map.end ()) {
-		platform::string message { PSTR("Unknown GAS FPU type: ") };
-		message.append (value);
+		std::string message { "Unknown GAS FPU type: " };
+		message.append (to_utf8 (value));
 		throw invalid_argument_error { message };
 	}
 
 	if (mc_fpu->second.empty ()) {
-		platform::string message { PSTR("Unable to map known GAS FPU type '") };
-		message.append (value);
-		message.append (PSTR("' to llvm-mc value"));
+		std::string message { "Unable to map known GAS FPU type '" };
+		message.append (to_utf8 (value));
+		message.append ("' to llvm-mc value");
 		throw invalid_operation_error { message };
 	}
 
diff --git a/src/gas/main.cc b/src/gas/main.cc
index 4785f13..aca2ea8 100644
--- a/src/gas/main.cc
+++ b/src/gas/main.cc
@@ -1,14 +1,16 @@
 // SPDX-License-Identifier: MIT
 #include <iostream>
+#include <vector>
+
 #include "gas.hh"
+#include "platform.hh"
 
 int main (int argc, char **argv)
 {
 	xamarin::android::gas::Gas app;
 
-	// On windows this obtains the utf8 version of args
-	app.get_command_line (argc, argv);
-	std::cout << "Command line converted" << std::endl;
+	std::vector<platform::string> args = app.get_command_line (argc, argv);
+
 	// TODO: handle exceptions here (use backward for stacktrace perhaps?)
-	return app.run (argc, argv);
+	return app.run (args);
 }
diff --git a/src/gas/process.cc b/src/gas/process.cc
index ca5b365..90b3766 100644
--- a/src/gas/process.cc
+++ b/src/gas/process.cc
@@ -13,26 +13,7 @@ void Process::print_process_command_line ()
 	for (platform::string const& arg : _args) {
 		STDOUT << " " << arg;
 	}
-	STDOUT << "\n";
-}
-
-std::vector<platform::string::const_pointer> Process::make_exec_args ()
-{
-	std::vector<platform::string::const_pointer> exec_args;
-
-	const char *const epath = executable_path.string ().c_str ();
-	exec_args.push_back (
-#if defined(_WIN32)
-		_strdup (epath)
-#else
-		strdup (epath)
-#endif
-	);
-	for (platform::string const& arg : _args) {
-		exec_args.push_back (arg.c_str ());
-	}
-
-	return exec_args;
+	STDOUT << Constants::newline;
 }
 
 void Process::append_program_argument (platform::string const& option_name, platform::string const& option_value)
diff --git a/src/gas/process.posix.cc b/src/gas/process.posix.cc
index b22c25c..ca7054a 100644
--- a/src/gas/process.posix.cc
+++ b/src/gas/process.posix.cc
@@ -13,6 +13,25 @@
 
 using namespace xamarin::android::gas;
 
+std::vector<platform::string::const_pointer> Process::make_exec_args ()
+{
+	std::vector<platform::string::const_pointer> exec_args;
+
+	const char *const epath = executable_path.string ().c_str ();
+	exec_args.push_back (
+#if defined(_WIN32)
+		_strdup (epath)
+#else
+		strdup (epath)
+#endif
+	);
+	for (platform::string const& arg : _args) {
+		exec_args.push_back (arg.c_str ());
+	}
+
+	return exec_args;
+}
+
 int Process::run (bool print_command_line)
 {
 	if (print_command_line) {
diff --git a/src/gas/process.windows.cc b/src/gas/process.windows.cc
index 43724ec..9dc3882 100644
--- a/src/gas/process.windows.cc
+++ b/src/gas/process.windows.cc
@@ -30,16 +30,16 @@ static platform::string escape_argument (platform::string arg)
 		return arg;
 	}
 
-	platform::string result = "\"";
+	platform::string result = L"\"";
 	for (platform::string::const_reference c : arg) {
-		if (c == '\"' || c == '\\') {
-			result.append ("\\");
+		if (c == L'\"' || c == L'\\') {
+			result.append (L"\\");
 		}
 
 		result += c;
 	}
 
-	result.append ("\"");
+	result.append (L"\"");
 	return result;
 }
 
@@ -49,23 +49,23 @@ int Process::run (bool print_command_line)
 		print_process_command_line ();
 	}
 
-	platform::string binary = executable_path.string ();
+	platform::string binary = executable_path.native ();
 	platform::string args { escape_argument (binary) };
 	for (platform::string const& a : _args) {
 		if (a.empty ()) {
 			continue;
 		}
-		args.append (" ");
+		args.append (L" ");
 		args.append (escape_argument (a));
 	}
 
-	int size =  MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, NULL , 0);
-	wchar_t* wargs = new wchar_t [size];
-	MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, wargs, size);
+	// int size =  MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, NULL , 0);
+	// wchar_t* wargs = new wchar_t [size];
+	// MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, wargs, size);
 
-	size =  MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, NULL , 0);
-	wchar_t* wbinary = new wchar_t [size];
-	MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, wbinary, size);
+	// size =  MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, NULL , 0);
+	// wchar_t* wbinary = new wchar_t [size];
+	// MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, wbinary, size);
 
 	PROCESS_INFORMATION pi {};
 	STARTUPINFOW si {};
@@ -73,8 +73,8 @@ int Process::run (bool print_command_line)
 
 	DWORD creation_flags = CREATE_UNICODE_ENVIRONMENT;
 	BOOL success = CreateProcessW (
-		wbinary,
-		wargs,
+		const_cast<LPWSTR>(binary.c_str ()),
+		const_cast<LPWSTR>(args.c_str ()),
 		nullptr, // process security attributes
 		nullptr, // primary thread security attributes
 		TRUE, // inherit handles
@@ -85,8 +85,8 @@ int Process::run (bool print_command_line)
 		&pi
 	);
 
-	delete[] wargs;
-	delete[] wbinary;
+	// delete[] wargs;
+	// delete[] wbinary;
 
 	if (!success) {
 		return Constants::wrapper_exec_failed_error_code;

From 8cd2c8af9aca40d9a895c2a57f72caa45b60f648 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 12:21:21 +0100
Subject: [PATCH 05/11] Passing `/utf-8` to MSVC appears to have fixed the
 issue...

...at least if we don't touch wide strings.  The code added in previous
commits to cope with narrow vs wide strings is left in place, "just in
case".  Both Unix and Windows builds effectively use narrow strings,
though.
---
 src/gas/command_line.cc         | 32 +++++++--------------
 src/gas/command_line.hh         | 10 +++----
 src/gas/constants.hh            |  4 +--
 src/gas/gas.cc                  | 50 +++++++++++++--------------------
 src/gas/gas.hh                  |  5 ----
 src/gas/gas.posix.cc            | 12 --------
 src/gas/gas.windows.cc          | 28 ------------------
 src/gas/llvm_mc_runner.cc       | 10 +++++--
 src/gas/llvm_mc_runner.hh       |  5 ++--
 src/gas/llvm_mc_runner_arm32.cc |  4 +--
 src/gas/platform.hh             | 12 ++++----
 src/gas/process.posix.cc        | 12 ++++----
 src/gas/process.windows.cc      | 32 ++++++++++-----------
 13 files changed, 76 insertions(+), 140 deletions(-)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index e2828f4..50c09ec 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -5,14 +5,13 @@
 #include <optional>
 
 #include "command_line.hh"
+#include "exceptions.hh"
 
 using namespace xamarin::android::gas;
 namespace ranges = std::ranges;
 
 bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector<platform::string> &args, OptionCallbackFn option_cb)
 {
-	STDOUT << "Got " << options.size() << " options\n" << "Passed args:\n";
-
 	uint32_t positional_count = 0;
 	bool next_arg_is_value = false;
 	std::optional<CommandLineOption> last_opt;
@@ -23,10 +22,7 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			continue;
 		}
 
-		STDOUT << "  [" << i << "] " << option << "\n";
-
 		platform::string::const_iterator iter = option.cbegin ();
-
 		while (iter != option.cend () && *iter == DASH) {
 			iter++;
 		}
@@ -37,7 +33,7 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			if (last_opt.has_value ()) {
 				option_cb (last_opt.value (), option);
 			} else {
-				// TODO: throw, probably
+				throw invalid_argument_error { "Option '" + option + "' requires an argument." };
 			}
 
 			next_arg_is_value = false;
@@ -45,12 +41,9 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			continue;
 		}
 
-		bool positional = iter == option.cbegin ();
-		STDOUT << std::boolalpha << "    Positional? " << positional << "\n";
-
 		platform::string_view option_name;
 		platform::string_view option_value;
-		if (positional) {
+		if (iter == option.cbegin ()) { // positional
 			option_cb ({ positional_count++ }, { option });
 			continue;
 		}
@@ -62,17 +55,11 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 
 		option_name = { name_start, iter };
 
-		bool has_value = iter != option.cend ();
-		STDOUT << "    Has value? " << has_value << "\n";
-
-		if (has_value) {
+		if (iter != option.cend ()) { // has a value
 			iter++;
 			option_value = { iter, option.cend () };
 		}
 
-		STDOUT << "     Option name: " << platform::string (option_name) << "\n";
-		STDOUT << "    Option value: " << platform::string (option_value) << "\n";
-
 		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {
 			if (o.name != option_name) {
 				return false;
@@ -82,9 +69,7 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 		};
 
 		auto match = ranges::find_if (options, matching_option);
-		if (match != options.end ()) {
-			STDOUT << "    found matching option\n";
-		} else {
+		if (match == options.end ()) {
 			STDERR << "Uncrecognized option '" << option << "'\n";
 			continue;
 		}
@@ -100,8 +85,11 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 	}
 
 	if (last_opt.has_value ()) {
-		STDERR << "Option '" << last_opt.value ().name << "' requires an argument" << std::endl;
-		return false;
+		platform::string message { "Option '" };
+		message
+			.append (last_opt.value ().name)
+			.append ("' requires an argument.");
+		throw invalid_operation_error {message};
 	}
 
 	return true;
diff --git a/src/gas/command_line.hh b/src/gas/command_line.hh
index a5ea73a..a4f57e6 100644
--- a/src/gas/command_line.hh
+++ b/src/gas/command_line.hh
@@ -77,14 +77,14 @@ namespace xamarin::android::gas
 		using TArgType = char*;
 
 	private:
-		static inline constexpr char DASH = '-';
-		static inline constexpr char EQUALS = '=';
+		static inline constexpr char DASH = PCHAR('-');
+		static inline constexpr char EQUALS = PCHAR('=');
 #else
 		using TArgType = LPWSTR;
 
 	private:
-		static inline constexpr wchar_t DASH = L'-';
-		static inline constexpr wchar_t EQUALS = L'=';
+		static inline constexpr wchar_t DASH = PCHAR('-');
+		static inline constexpr wchar_t EQUALS = PCHAR('=');
 #endif
 
 	public:
@@ -116,7 +116,7 @@ namespace xamarin::android::gas
 #if !defined (_WIN32)
 #define CLIPARAM(_str_lit_) std::string_view { _str_lit_ }
 #else
-#define CLIPARAM(_str_lit_) std::wstring_view { L##_str_lit_ }
+#define CLIPARAM(_str_lit_) std::string_view { _str_lit_ }
 #endif
 
 #endif // ndef GAS_COMMAND_LINE_HH
diff --git a/src/gas/constants.hh b/src/gas/constants.hh
index d29db8c..583ba5a 100644
--- a/src/gas/constants.hh
+++ b/src/gas/constants.hh
@@ -10,8 +10,8 @@ namespace xamarin::android::gas
 	{
 	public:
 #if defined (_WIN32)
-		static constexpr platform::string_view newline { L"\r\n" };
-		static constexpr platform::string_view llvm_mc_name { L"llvm-mc.exe" };
+		static constexpr platform::string_view newline { PSTR("\r\n") };
+		static constexpr platform::string_view llvm_mc_name { PSTR("llvm-mc.exe") };
 #else
 		static constexpr platform::string_view newline { "\n" };
 		static constexpr platform::string_view llvm_mc_name { "llvm-mc" };
diff --git a/src/gas/gas.cc b/src/gas/gas.cc
index c4c856c..2b0759a 100644
--- a/src/gas/gas.cc
+++ b/src/gas/gas.cc
@@ -58,12 +58,20 @@ int Gas::usage (bool is_error, platform::string const message)
 	return is_error ? 1 : 0;
 }
 
+std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
+{
+	std::vector<platform::string> ret;
+
+	for (int i = 0; i < argc; i++) {
+		ret.emplace_back (argv[i]);
+	}
+
+	return ret;
+}
+
 int Gas::run (std::vector<platform::string> args)
 {
-	STDOUT << "Gas::run" << std::endl;
 	determine_program_dir (args);
-	STDOUT << "Program dir determined" << std::endl;
-
 	auto lowercase_string = [](platform::string& s) {
 		std::transform (
 			s.begin (),
@@ -73,14 +81,12 @@ int Gas::run (std::vector<platform::string> args)
 		);
 	};
 
-	STDOUT << "Determining arch name" << std::endl;
 	platform::string arch_name { generic_gas_name };
 	platform::string first_param { args.size () > 1 ? args[1] : PSTR("") };
 	if (!first_param.empty () && first_param.length () > Constants::arch_hack_param.size () && first_param.find (Constants::arch_hack_param) == 0) {
 		arch_name = first_param.substr (Constants::arch_hack_param.size ());
 		lowercase_string (arch_name);
 	}
-	STDOUT << "arch_name == " << arch_name << std::endl;
 	_program_name = arch_name;
 
 	std::unique_ptr<LlvmMcRunner> mc_runner;
@@ -114,21 +120,19 @@ int Gas::run (std::vector<platform::string> args)
 		return usage (true /* is_error */, message);
 	} else {
 		platform::string message { PSTR("Unknown program name '") };
-		message.append (arch_name).append (PSTR("'")).append (Constants::newline);
+		message
+			.append (arch_name)
+			.append (PSTR("'"))
+			.append (Constants::newline);
 		return usage (true /* is_error */, message);
 	}
 
-	STDOUT << "About to parse arguments" << std::endl;
 	auto&& [terminate, is_error] = parse_arguments (args, mc_runner);
-	STDOUT << "Arguments parsed; terminate == " << terminate << "; is_error == " << is_error << std::endl;
 	if (terminate || is_error) {
 		return is_error ? Constants::wrapper_general_error_code : 0;
 	}
 
-	STDOUT << "Getting path to llvm_mc" << std::endl;
 	fs::path llvm_mc = program_dir () / Constants::llvm_mc_name;
-	STDOUT << "llvm_mc == " << llvm_mc.c_str () << std::endl;
-
 	bool multiple_input_files = false;
 	bool derive_output_file_name = false;
 	switch (input_files.size ()) {
@@ -151,11 +155,10 @@ int Gas::run (std::vector<platform::string> args)
 	}
 
 	for (fs::path const& input : input_files) {
-		STDOUT << "running llvm-mc for '" << input.c_str () << std::endl;
 		mc_runner->set_input_file_path (input, derive_output_file_name);
 		int ret = mc_runner->run (llvm_mc);
 		if (ret != 0) {
-			STDOUT << "  mc_runner failed with " << ret << std::endl;
+			STDERR << "  mc_runner failed with error code " << ret << Constants::newline;
 			return ret;
 		}
 	}
@@ -170,13 +173,11 @@ int Gas::run (std::vector<platform::string> args)
 		ld_path /= ld_name;
 		auto ld = std::make_unique<Process> (ld_path);
 		ld->append_program_argument (PSTR("-o"));
-		ld->append_program_argument (_gas_output_file.empty () ? platform::string (Constants::default_output_name) : _gas_output_file.native ());
+		ld->append_program_argument (_gas_output_file.empty () ? platform::string (Constants::default_output_name) : _gas_output_file.string ());
 		ld->append_program_argument (PSTR("--relocatable"));
 
-		STDOUT << "Have multiple output files:" << Constants::newline;
 		for (fs::path const& output : output_files) {
-			STDOUT << "  " << output << Constants::newline;
-			ld->append_program_argument (output.native ());
+			ld->append_program_argument (output.string ());
 		}
 
 		return ld->run ();
@@ -229,31 +230,20 @@ Gas::ParseArgsResult Gas::parse_arguments (std::vector<platform::string> &args,
 		if (std::holds_alternative<uint32_t> (option)) {
 			platform::string arg = std::get<platform::string> (val);
 			// Positional argument
-			STDOUT << "Positional argument no. " << std::get<uint32_t> (option) << ": " << arg << "\n";
 			if (arg.starts_with (Constants::arch_hack_param)) {
 				// Arch hack, ignore
-				STDOUT << "  arch hack param, ignored\n";
 				return;
 			}
 
-			STDOUT << "  input file\n";
 			input_files.emplace_back (arg);
 			return;
 		}
 
 		const auto opt = std::get<const CommandLineOption> (option);
-		STDOUT << "Option argument: " << platform::string (opt.name) << "\n";
 		if (opt.id == OptionId::Ignore) {
-			STDOUT << "  ignored\n";
 			return;
 		}
 
-		if (std::holds_alternative<bool> (val)) {
-			STDOUT << "  boolean\n";
-		} else {
-			STDOUT << "  value: " << std::get<platform::string> (val) << "\n";
-		}
-
 		switch (opt.id) {
 			case OptionId::Version:
 				show_version = true;
@@ -298,8 +288,8 @@ Gas::ParseArgsResult Gas::parse_arguments (std::vector<platform::string> &args,
 		return {true, false};
 	} else if (show_version) {
 		STDOUT << program_name () << " v" << XA_UTILS_VERSION << ", " << PROGRAM_DESCRIPTION << Constants::newline
-		          << "\tGAS version compatibility: " << BINUTILS_VERSION << Constants::newline
-		          << "\tllvm-mc version compatibility: " << LLVM_VERSION << Constants::newline << Constants::newline;
+		       << "\tGAS version compatibility: " << BINUTILS_VERSION << Constants::newline
+		       << "\tllvm-mc version compatibility: " << LLVM_VERSION << Constants::newline << Constants::newline;
 		return {true, false};
 	}
 
diff --git a/src/gas/gas.hh b/src/gas/gas.hh
index 26e9ae2..5c6c6d4 100644
--- a/src/gas/gas.hh
+++ b/src/gas/gas.hh
@@ -5,17 +5,13 @@
 #if !defined(_WIN32)
 #include <unistd.h>
 #endif
-#include <getopt.h>
 
 #include <array>
 #include <concepts>
 #include <filesystem>
-#include <iostream>
 #include <memory>
-#include <string>
 #include <vector>
 
-#include "command_line.hh"
 #include "constants.hh"
 #include "platform.hh"
 
@@ -171,5 +167,4 @@ namespace xamarin::android::gas
 		TargetArchitecture  _target_arch;
 	};
 }
-
 #endif // __GAS_HH
diff --git a/src/gas/gas.posix.cc b/src/gas/gas.posix.cc
index 8a667d9..84b5010 100644
--- a/src/gas/gas.posix.cc
+++ b/src/gas/gas.posix.cc
@@ -10,20 +10,8 @@
 
 using namespace xamarin::android::gas;
 
-std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
-{
-	std::vector<platform::string> ret;
-
-	for (int i = 0; i < argc; i++) {
-		ret.emplace_back (argv[i]);
-	}
-
-	return ret;
-}
-
 void Gas::determine_program_dir (std::vector<platform::string> args)
 {
-	STDOUT << args[0] << std::endl;
 	fs::path program_path { args[0] };
 
 	_program_name = program_path.filename ();
diff --git a/src/gas/gas.windows.cc b/src/gas/gas.windows.cc
index d7a63e2..e421539 100644
--- a/src/gas/gas.windows.cc
+++ b/src/gas/gas.windows.cc
@@ -12,34 +12,6 @@
 
 using namespace xamarin::android::gas;
 
-std::vector<platform::string> Gas::get_command_line (int &argc, char **&argv)
-{
-	for (int i = 0; i < argc; i++) {
-		std::printf ("[A][%d] %s\n", i, argv[i]);
-	}
-
-	LPWSTR *szArglist;
-	int nArgs;
-	int i;
-
-	szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
-	if( NULL == szArglist ) {
-		wprintf(L"CommandLineToArgvW failed\n");
-		return {};
-	} else for( i=0; i<nArgs; i++) printf("[W] %d: %ws\n", i, szArglist[i]);
-
-	int n_args;
-	LPWSTR *argv_wide = CommandLineToArgvW (GetCommandLineW (), &n_args);
-	std::vector<platform::string> ret;
-
-	for (int i = 0; i < n_args; i++) {
-		std::printf ("[W][%d] %ws\n", i, argv_wide[i]);
-		ret.emplace_back (argv_wide[i]);
-	}
-
-	return ret;
-}
-
 void Gas::determine_program_dir (std::vector<platform::string> args)
 {
 	TCHAR buffer[MAX_PATH + 1]{};
diff --git a/src/gas/llvm_mc_runner.cc b/src/gas/llvm_mc_runner.cc
index c78988e..965fc94 100644
--- a/src/gas/llvm_mc_runner.cc
+++ b/src/gas/llvm_mc_runner.cc
@@ -25,8 +25,12 @@ std::unordered_map<LlvmMcArgument, bool> LlvmMcRunner::known_options {
 
 int LlvmMcRunner::run (fs::path const& executable_path)
 {
-	auto process = std::make_unique<Process> (executable_path);
+	if (!fs::exists (executable_path)) {
+		STDERR << "Executable '" << executable_path.string () << "' does not exist." << Constants::newline;
+		return Constants::wrapper_exec_failed_error_code;
+	}
 
+	auto process = std::make_unique<Process> (executable_path);
 	auto opt = arguments.find (LlvmMcArgument::Arch);
 	if (opt != arguments.end ()) {
 		process->append_program_argument (PSTR("--arch"), opt->second);
@@ -55,8 +59,8 @@ int LlvmMcRunner::run (fs::path const& executable_path)
 		process->append_program_argument (PSTR("-o"), opt->second);
 	}
 
-	platform::string input_file { PSTR("\"") + input_file_path.make_preferred ().native () + PSTR("\"") };
-	process->append_program_argument (input_file_path.make_preferred ().native ());
+	platform::string input_file { PSTR("\"") + input_file_path.make_preferred ().string () + PSTR("\"") };
+	process->append_program_argument (input_file_path.make_preferred ().string ());
 
 	return process->run ();
 }
diff --git a/src/gas/llvm_mc_runner.hh b/src/gas/llvm_mc_runner.hh
index 6db1008..afb7cd5 100644
--- a/src/gas/llvm_mc_runner.hh
+++ b/src/gas/llvm_mc_runner.hh
@@ -3,7 +3,6 @@
 #define __LLVM_MC_RUNNER_HH
 
 #include <filesystem>
-#include <functional>
 #include <unordered_map>
 #include <vector>
 
@@ -69,7 +68,7 @@ namespace xamarin::android::gas
 
 		void set_output_file_path (fs::path const& file_path)
 		{
-			set_option (LlvmMcArgument::Output, file_path.native ());
+			set_option (LlvmMcArgument::Output, file_path.string ());
 		}
 
 		void add_include_path (fs::path const& include_path)
@@ -78,7 +77,7 @@ namespace xamarin::android::gas
 				return;
 			}
 
-			set_option (LlvmMcArgument::IncludeDir, include_path.native ());
+			set_option (LlvmMcArgument::IncludeDir, include_path.string ());
 		}
 
 		void generate_debug_info ()
diff --git a/src/gas/llvm_mc_runner_arm32.cc b/src/gas/llvm_mc_runner_arm32.cc
index f79f57b..a28ba01 100644
--- a/src/gas/llvm_mc_runner_arm32.cc
+++ b/src/gas/llvm_mc_runner_arm32.cc
@@ -1,10 +1,8 @@
 // SPDX-License-Identifier: MIT
 
-#include <locale>
-
-#include "command_line.hh"
 #include "exceptions.hh"
 #include "llvm_mc_runner.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 
diff --git a/src/gas/platform.hh b/src/gas/platform.hh
index 7a89183..80d241f 100644
--- a/src/gas/platform.hh
+++ b/src/gas/platform.hh
@@ -6,13 +6,15 @@
 #include <iostream>
 
 #if defined(_WIN32)
-#define STDOUT std::wcout
-#define STDERR std::wcerr
-#define PSTR(_str_lit_) (L##_str_lit_)
+#define STDOUT std::cout
+#define STDERR std::cerr
+#define PSTR(_str_lit_) (_str_lit_)
+#define PCHAR(_ch_) (_ch_)
 #else
 #define STDOUT std::cout
 #define STDERR std::cerr
 #define PSTR(_str_lit_) (_str_lit_)
+#define PCHAR(_ch_) (_ch_)
 #endif
 
 namespace platform {
@@ -20,8 +22,8 @@ namespace platform {
 	using string = std::string;
 	using string_view = std::string_view;
 #else
-	using string = std::wstring;
-	using string_view = std::wstring_view;
+	using string = std::string;
+	using string_view = std::string_view;
 #endif
 }
 
diff --git a/src/gas/process.posix.cc b/src/gas/process.posix.cc
index ca7054a..d8f48af 100644
--- a/src/gas/process.posix.cc
+++ b/src/gas/process.posix.cc
@@ -52,13 +52,13 @@ int Process::run (bool print_command_line)
 
 	pid_t llvm_mc_pid = fork ();
 	if (llvm_mc_pid == -1) {
-		std::cerr << "Fork failed. " << std::strerror (errno) << Constants::newline;
+		STDERR << "Fork failed. " << std::strerror (errno) << Constants::newline;
 		return Constants::wrapper_fork_failed_error_code;
 	}
 
 	if (llvm_mc_pid == 0) {
 		if (execv (executable_path.c_str (), const_cast<char* const*>(exec_args.data ())) == -1) {
-			std::cerr << "Failed to run " << Constants::llvm_mc_name << ". " << std::strerror (errno) << Constants::newline;
+			STDERR << "Failed to run " << Constants::llvm_mc_name << ". " << std::strerror (errno) << Constants::newline;
 		}
 		_exit (Constants::wrapper_exec_failed_error_code);
 	}
@@ -68,22 +68,22 @@ int Process::run (bool print_command_line)
 		pid_t result = waitpid (llvm_mc_pid,  &wstatus, WUNTRACED);
 
 		if (result == -1) {
-			std::cerr << "Failed to wait for " << Constants::llvm_mc_name << " to terminate. " << std::strerror (errno) << Constants::newline;
+			STDERR << "Failed to wait for " << Constants::llvm_mc_name << " to terminate. " << std::strerror (errno) << Constants::newline;
 			return Constants::wrapper_wait_failed_error_code;
 		}
 
 		if (WIFSIGNALED (wstatus)) {
-			std::cerr << Constants::llvm_mc_name << " was killed by signal " << WTERMSIG (wstatus) << Constants::newline;
+			STDERR << Constants::llvm_mc_name << " was killed by signal " << WTERMSIG (wstatus) << Constants::newline;
 			return Constants::wrapper_llvm_mc_killed_error_code;
 		} else if (WIFSTOPPED (wstatus)) {
-			std::cerr << Constants::llvm_mc_name << " was stopped by signal " << WSTOPSIG (wstatus) << Constants::newline;
+			STDERR << Constants::llvm_mc_name << " was stopped by signal " << WSTOPSIG (wstatus) << Constants::newline;
 			kill (llvm_mc_pid, SIGKILL); // Let's not risk hanging indifinitely...
 			return Constants::wrapper_llvm_mc_stopped_error_code;
 		}
 	} while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus));
 
 	if (WEXITSTATUS (wstatus) != 0) {
-		std::cerr << Constants::llvm_mc_name << " exited with status " << WEXITSTATUS (wstatus) << Constants::newline;
+		STDERR << Constants::llvm_mc_name << " exited with status " << WEXITSTATUS (wstatus) << Constants::newline;
 	}
 	return WEXITSTATUS (wstatus);
 }
diff --git a/src/gas/process.windows.cc b/src/gas/process.windows.cc
index 9dc3882..7edb57b 100644
--- a/src/gas/process.windows.cc
+++ b/src/gas/process.windows.cc
@@ -30,16 +30,16 @@ static platform::string escape_argument (platform::string arg)
 		return arg;
 	}
 
-	platform::string result = L"\"";
+	platform::string result = PSTR("\"");
 	for (platform::string::const_reference c : arg) {
-		if (c == L'\"' || c == L'\\') {
-			result.append (L"\\");
+		if (c == PCHAR('\"') || c == PCHAR('\\')) {
+			result.append (PCHAR("\\"));
 		}
 
 		result += c;
 	}
 
-	result.append (L"\"");
+	result.append (PSTR("\""));
 	return result;
 }
 
@@ -49,23 +49,23 @@ int Process::run (bool print_command_line)
 		print_process_command_line ();
 	}
 
-	platform::string binary = executable_path.native ();
+	platform::string binary = executable_path.string ();
 	platform::string args { escape_argument (binary) };
 	for (platform::string const& a : _args) {
 		if (a.empty ()) {
 			continue;
 		}
-		args.append (L" ");
+		args.append (PCHAR(" "));
 		args.append (escape_argument (a));
 	}
 
-	// int size =  MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, NULL , 0);
-	// wchar_t* wargs = new wchar_t [size];
-	// MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, wargs, size);
+	int size =  MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, NULL , 0);
+	wchar_t* wargs = new wchar_t [size];
+	MultiByteToWideChar (CP_UTF8, 0, args.c_str (), -1, wargs, size);
 
-	// size =  MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, NULL , 0);
-	// wchar_t* wbinary = new wchar_t [size];
-	// MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, wbinary, size);
+	size =  MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, NULL , 0);
+	wchar_t* wbinary = new wchar_t [size];
+	MultiByteToWideChar (CP_UTF8, 0, binary.c_str (), -1, wbinary, size);
 
 	PROCESS_INFORMATION pi {};
 	STARTUPINFOW si {};
@@ -73,8 +73,8 @@ int Process::run (bool print_command_line)
 
 	DWORD creation_flags = CREATE_UNICODE_ENVIRONMENT;
 	BOOL success = CreateProcessW (
-		const_cast<LPWSTR>(binary.c_str ()),
-		const_cast<LPWSTR>(args.c_str ()),
+		wbinary,
+		wargs,
 		nullptr, // process security attributes
 		nullptr, // primary thread security attributes
 		TRUE, // inherit handles
@@ -85,8 +85,8 @@ int Process::run (bool print_command_line)
 		&pi
 	);
 
-	// delete[] wargs;
-	// delete[] wbinary;
+	delete[] wargs;
+	delete[] wbinary;
 
 	if (!success) {
 		return Constants::wrapper_exec_failed_error_code;

From 90530f190d967011ddc09af73fc6d5472d6c56be Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 15:03:48 +0100
Subject: [PATCH 06/11] Fix macOS build

---
 src/gas/command_line.cc | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 50c09ec..5593e51 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -68,7 +68,12 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			return o.arch == TargetArchitecture::Any || o.arch == target_arch;
 		};
 
+#if !defined(__APPLE__)
 		auto match = ranges::find_if (options, matching_option);
+#else
+		// C++ standard library on mac CI doesn't have std::ranges::find_if
+		auto match = std::find_if (options. matching_option);
+#endif
 		if (match == options.end ()) {
 			STDERR << "Uncrecognized option '" << option << "'\n";
 			continue;

From aaebc672a91697e25d65327f8cc8e858a82e7706 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 15:09:25 +0100
Subject: [PATCH 07/11] More macOS fixes

---
 src/gas/command_line.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 5593e51..c549071 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: MIT
 
 #include <algorithm>
-#include <iostream>
 #include <optional>
+#include <vector>
 
 #include "command_line.hh"
 #include "exceptions.hh"
+#include "platform.hh"
 
 using namespace xamarin::android::gas;
 namespace ranges = std::ranges;

From 6f36d3cb5cac12a4dc51531d5a51133cb1f9fa06 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 15:24:32 +0100
Subject: [PATCH 08/11] More macOS fixes (builds locally...)

---
 src/gas/command_line.cc  | 2 +-
 src/gas/process.posix.cc | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index c549071..5d06701 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -73,7 +73,7 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 		auto match = ranges::find_if (options, matching_option);
 #else
 		// C++ standard library on mac CI doesn't have std::ranges::find_if
-		auto match = std::find_if (options. matching_option);
+		auto match = std::find_if (options.begin (), options.end (), matching_option);
 #endif
 		if (match == options.end ()) {
 			STDERR << "Uncrecognized option '" << option << "'\n";
diff --git a/src/gas/process.posix.cc b/src/gas/process.posix.cc
index d8f48af..7527df3 100644
--- a/src/gas/process.posix.cc
+++ b/src/gas/process.posix.cc
@@ -17,7 +17,15 @@ std::vector<platform::string::const_pointer> Process::make_exec_args ()
 {
 	std::vector<platform::string::const_pointer> exec_args;
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdangling-gsl"
+	// The object returned from string() is temporary, but we don't really care about it
+	// and the warning generated by -Wdangling-gsl was effectively non-actionable:
+	//  warning: object backing the pointer will be destroyed at the end of the full-expression
+	//
 	const char *const epath = executable_path.string ().c_str ();
+#pragma clang diagnostic pop
+
 	exec_args.push_back (
 #if defined(_WIN32)
 		_strdup (epath)

From 57163b715e68abf79edc3589d04dfd02608056f8 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 15:32:46 +0100
Subject: [PATCH 09/11] How about this, AppleClang 13?

---
 src/gas/command_line.cc | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 5d06701..1fb6cec 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -42,8 +42,6 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			continue;
 		}
 
-		platform::string_view option_name;
-		platform::string_view option_value;
 		if (iter == option.cbegin ()) { // positional
 			option_cb ({ positional_count++ }, { option });
 			continue;
@@ -54,11 +52,12 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			iter++;
 		}
 
-		option_name = { name_start, iter };
+		platform::string_view option_name (name_start, iter);
+		platform::string_view option_value;
 
 		if (iter != option.cend ()) { // has a value
 			iter++;
-			option_value = { iter, option.cend () };
+			option_value = platform::string_view (iter, option.cend ());
 		}
 
 		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {

From baf55aef04188be3d97807f4ca06cbadc8d6ed04 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 16:09:41 +0100
Subject: [PATCH 10/11] OK, let's see if that works

---
 src/gas/command_line.cc | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/gas/command_line.cc b/src/gas/command_line.cc
index 1fb6cec..bf59ebe 100644
--- a/src/gas/command_line.cc
+++ b/src/gas/command_line.cc
@@ -52,12 +52,20 @@ bool CommandLine::parse (std::span<const CommandLineOption> options, std::vector
 			iter++;
 		}
 
-		platform::string_view option_name (name_start, iter);
+#if !defined (__APPLE__)
+		platform::string_view option_name { name_start, iter };
+#else
+		platform::string_view option_name (option.data () + (name_start - option.cbegin ()), iter - name_start);
+#endif
 		platform::string_view option_value;
 
 		if (iter != option.cend ()) { // has a value
 			iter++;
-			option_value = platform::string_view (iter, option.cend ());
+#if !defined (__APPLE__)
+			option_value = { iter, option.cend () };
+#else
+			option_value = platform::string_view (option.data () + (iter - option.cbegin ()), option.cend () - iter);
+#endif
 		}
 
 		auto matching_option = [this, &option_name] (CommandLineOption const& o) -> bool {

From 808b9589b3a14a3d4afa05f7850b53fcafb14de3 Mon Sep 17 00:00:00 2001
From: Marek Habersack <grendel@twistedcode.net>
Date: Tue, 26 Mar 2024 17:40:31 +0100
Subject: [PATCH 11/11] Address feedback

---
 src/gas/process.posix.cc | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/src/gas/process.posix.cc b/src/gas/process.posix.cc
index 7527df3..27fd7c8 100644
--- a/src/gas/process.posix.cc
+++ b/src/gas/process.posix.cc
@@ -17,20 +17,11 @@ std::vector<platform::string::const_pointer> Process::make_exec_args ()
 {
 	std::vector<platform::string::const_pointer> exec_args;
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdangling-gsl"
-	// The object returned from string() is temporary, but we don't really care about it
-	// and the warning generated by -Wdangling-gsl was effectively non-actionable:
-	//  warning: object backing the pointer will be destroyed at the end of the full-expression
-	//
-	const char *const epath = executable_path.string ().c_str ();
-#pragma clang diagnostic pop
-
 	exec_args.push_back (
 #if defined(_WIN32)
-		_strdup (epath)
+		_strdup (executable_path.string ().c_str ())
 #else
-		strdup (epath)
+		strdup (executable_path.string ().c_str ())
 #endif
 	);
 	for (platform::string const& arg : _args) {