Add OpenVicProject/lauf@8f3b2dc

Author: Spartan322

.gitmodules

@@ -26,3 +26,6 @@
 [submodule "tests/benchmarks/deps/nanobench"]
 	path = tests/benchmarks/deps/nanobench
 	url = https://github.com/Spartan322/nanobench
+[submodule "deps/lauf"]
+	path = deps/lauf
+	url = https://github.com/OpenVicProject/lauf

deps/SCsub

@@ -45,6 +45,61 @@ def build_std_function(env):
     env.Append(CPPPATH=env.std_function["INCPATH"])
     env.exposed_includes += env.std_function["INCPATH"]
 
+def build_lauf(env):
+    import os
+
+    if env.get("use_clang_cl", False) or env["CXX"] == "clang++" or (not env.get("is_msvc", False) and env["optimize"] != "none"):
+        env.Append(CPPDEFINES=["LAUF_HAS_TAIL_CALL_ELIMINATION=1"])
+
+    lauf_env = env.Clone()
+
+    if lauf_env.get("is_msvc", False):
+        lauf_env.Append(CXXFLAGS=["/WX", "/W3", "/D", "_CRT_SECURE_NO_WARNINGS"])
+        if lauf_env.get("use_clang_cl"):
+            lauf_env.Append(CXXFLAGS=["-Wno-return-type-c-linkage", "-fomit-frame-pointer"])
+            lauf_env.Append(CXXFLAGS=["/wd5105"])
+        else:
+            lauf_env.Append(CXXFLAGS=["/Oy"])
+    else:
+        lauf_env.Append(CXXFLAGS=["-pedantic-errors", "-Werror", "-Wall", "-Wextra", "-Wconversion", "-Wsign-conversion", "-fomit-frame-pointer"])
+        if lauf_env["CXX"] == "clang++":
+            lauf_env.Append(CXXFLAGS=["-Wno-return-type-c-linkage"])
+            lauf_env.Append(CXXFLAGS=["-Wno-shift-op-parentheses", "-Wno-parentheses-equality"])
+        else:
+            lauf_env.Append(
+                CXXFLAGS=[
+                    "-Wno-parentheses",
+                    "-Wno-unused-local-typedefs",
+                    "-Wno-array-bounds",  # , "-Wno-maybe-uninitialized", "-Wno-restrict"
+                ]
+            )
+
+    lexy_include_path = "openvic-dataloader/deps/lexy/include"
+    include_path = "lauf/include"
+    source_path = "lauf/src"
+    lauf_env.Append(CPPPATH=[[lauf_env.Dir(p) for p in [lexy_include_path, source_path, include_path]]])
+    sources = lauf_env.GlobRecursive("*.cpp", [source_path])
+    env.lauf_sources = sources
+
+    library_name = "liblauf" + env["LIBSUFFIX"]
+    library = lauf_env.StaticLibrary(target=os.path.join(source_path, library_name), source=sources)
+    Default(library)
+
+    include_dir = lauf_env.Dir(include_path)
+    source_dir = lauf_env.Dir(source_path)
+
+    env.lauf = {}
+    env.lauf["INCPATH"] = [env.Dir(include_path)]
+
+    env.Append(CPPPATH=env.lauf["INCPATH"])
+    if env.get("is_msvc", False):
+        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
+    else:
+        env.Append(CXXFLAGS=["-isystem", include_dir])
+    env.Append(LIBPATH=[source_dir])
+    env.Prepend(LIBS=[library_name])
+    env.exposed_includes += env.lauf["INCPATH"]
+
 def link_tbb(env):
     import sys
     if not env.get("is_msvc", False) and not env.get("use_mingw", False) and sys.platform != "darwin":
@@ -56,4 +111,5 @@ build_ordered_map(env)
 build_colony(env)
 build_function2(env)
 build_std_function(env)
+build_lauf(env)
 link_tbb(env)

deps/lauf

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "openvic-simulation/vm/Chunk.hpp"
+#include "openvic-simulation/vm/CodeBuilder.hpp"
+#include "openvic-simulation/vm/Function.hpp"
+#include "openvic-simulation/vm/Handler.hpp"
+#include "openvic-simulation/vm/Module.hpp"
+
+#include <lauf/asm/builder.h>
+#include <lauf/asm/module.h>
+
+namespace OpenVic::Vm {
+	struct AsmBuilderRef : HandlerRef<lauf_asm_builder> {
+		using HandlerRef::HandlerRef;
+
+		CodeBuilder& build(ModuleRef module, Function function) {
+			_current_builder = { *this, module, function };
+			return _current_builder;
+		}
+
+		CodeBuilder& build(ModuleRef module, Chunk chunk, lauf_asm_signature signature) {
+			_current_builder = { *this, module, chunk, signature };
+			return _current_builder;
+		}
+
+		CodeBuilder& current_builder() {
+			return _current_builder;
+		}
+
+	private:
+		CodeBuilder _current_builder { *this };
+	};
+
+	struct AsmBuilder : UniqueHandlerDerived<AsmBuilder, AsmBuilderRef> {
+		using UniqueHandlerDerived::UniqueHandlerDerived;
+		using UniqueHandlerDerived::operator=;
+
+		AsmBuilder(lauf_asm_build_options options = lauf_asm_default_build_options)
+			: UniqueHandlerDerived(lauf_asm_create_builder(options)) {}
+
+		~AsmBuilder() {
+			if (_handle == nullptr) {
+				return;
+			}
+			lauf_asm_destroy_builder(*this);
+			_handle = nullptr;
+		}
+	};
+}

src/openvic-simulation/vm/AsmBuilder.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "openvic-simulation/vm/Handler.hpp"
+
+#include <lauf/asm/module.h>
+
+namespace OpenVic::Vm {
+	struct Chunk : HandlerRef<lauf_asm_chunk> {
+		using HandlerRef::HandlerRef;
+
+		lauf_asm_signature signature() const {
+			return lauf_asm_chunk_signature(*this);
+		}
+
+		bool is_empty() const {
+			return lauf_asm_chunk_is_empty(*this);
+		}
+	};
+}

src/openvic-simulation/vm/Chunk.hpp

@@ -0,0 +1,23 @@
+#include "CodeBuilder.hpp"
+
+#include "openvic-simulation/vm/AsmBuilder.hpp"
+
+#include <lauf/asm/builder.h>
+
+using namespace OpenVic::Vm;
+
+CodeBuilder::CodeBuilder(AsmBuilderRef builder) : HandlerRef(builder), _module(nullptr), _body({ .chunk { false, nullptr } }) {}
+
+CodeBuilder::CodeBuilder(AsmBuilderRef builder, ModuleRef module, Function function)
+	: HandlerRef(builder), _module(module), _body({ .function = { true, function } }) {
+	lauf_asm_build(builder, _module, _body.function.value);
+}
+
+CodeBuilder::CodeBuilder(AsmBuilderRef builder, ModuleRef module, Chunk chunk, lauf_asm_signature signature)
+	: HandlerRef(builder), _module(module), _body({ .chunk = { false, chunk } }) {
+	lauf_asm_build_chunk(builder, _module, _body.chunk.value, signature);
+}
+
+AsmBuilderRef CodeBuilder::asm_builder() {
+	return _handle;
+}

src/openvic-simulation/vm/CodeBuilder.cpp

@@ -0,0 +1,101 @@
+#pragma once
+
+#include <bit>
+#include <string_view>
+
+#include "openvic-simulation/vm/Handler.hpp"
+#include "openvic-simulation/vm/Local.hpp"
+#include "openvic-simulation/vm/Module.hpp"
+
+#include <lauf/asm/builder.h>
+#include <lauf/asm/module.h>
+
+namespace OpenVic::Vm {
+	struct AsmBuilderRef;
+
+	struct CodeBuilder : HandlerRef<lauf_asm_builder> {
+		AsmBuilderRef asm_builder();
+
+		ModuleRef module() {
+			return _module;
+		}
+
+		bool is_function() const {
+			return _body.function.is_function;
+		}
+
+		bool is_chunk() const {
+			return !_body.chunk.is_function && _body.chunk.value != nullptr;
+		}
+
+		bool can_build() const {
+			return !_body.chunk.is_function && _body.chunk.value == nullptr;
+		}
+
+		Function function() const {
+			assert(is_function());
+			return _body.function.value;
+		}
+
+		Chunk chunk() const {
+			assert(is_chunk());
+			return _body.chunk.value;
+		}
+
+		Global build_literal(const std::span<unsigned char> data) {
+			return lauf_asm_build_data_literal(*this, data.data(), data.size_bytes());
+		}
+
+		Global build_string(std::string_view string) {
+			return lauf_asm_build_data_literal(
+				*this, std::bit_cast<unsigned char*>(string.data()), string.size() * sizeof(char)
+			);
+		}
+
+		Global build_cstring(const char* string) {
+			return lauf_asm_build_string_literal(*this, string);
+		}
+
+		Local build_local(lauf_asm_layout layout) {
+			return lauf_asm_build_local(*this, layout);
+		}
+
+		void drop() && {
+			_body.chunk.is_function = false;
+			_body.chunk.value = nullptr;
+		}
+
+		bool finish() && {
+			bool result = lauf_asm_build_finish(*this);
+			static_cast<CodeBuilder&&>(*this).drop();
+			return result;
+		}
+
+		~CodeBuilder() {
+			if (_handle == nullptr || !can_build()) {
+				return;
+			}
+			static_cast<CodeBuilder&&>(*this).finish();
+			_handle = nullptr;
+		}
+
+	protected:
+		friend struct AsmBuilderRef;
+		CodeBuilder(AsmBuilderRef builder);
+		CodeBuilder(AsmBuilderRef builder, ModuleRef module, Function function);
+		CodeBuilder(AsmBuilderRef builder, ModuleRef module, Chunk chunk, lauf_asm_signature signature);
+
+		ModuleRef _module;
+
+		union {
+			struct {
+				bool is_function;
+				lauf_asm_function* value;
+			} function;
+			struct {
+				bool is_function;
+				lauf_asm_chunk* value;
+			} chunk;
+		} _body;
+	};
+}

src/openvic-simulation/vm/CodeBuilder.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <cassert>
+#include <string_view>
+
+#include "openvic-simulation/vm/Handler.hpp"
+
+#include <lauf/asm/module.h>
+
+namespace OpenVic::Vm {
+	struct Function : HandlerRef<lauf_asm_function> {
+		using HandlerRef::HandlerRef;
+
+		std::string_view name() const {
+			return lauf_asm_function_name(*this);
+		}
+
+		lauf_asm_signature signature() const {
+			return lauf_asm_function_signature(*this);
+		}
+
+		bool has_definition() const {
+			return lauf_asm_function_has_definition(*this);
+		}
+
+		size_t get_instruction_by_index(lauf_asm_inst const* ip) const {
+			return lauf_asm_get_instruction_index(*this, ip);
+		}
+
+		void set_export() {
+			lauf_asm_export_function(*this);
+		}
+	};
+}

src/openvic-simulation/vm/Function.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string_view>
+
+#include "openvic-simulation/vm/Handler.hpp"
+
+#include <lauf/asm/module.h>
+#include <lauf/asm/type.h>
+
+namespace OpenVic::Vm {
+	struct Global : HandlerRef<lauf_asm_global> {
+		using HandlerRef::HandlerRef;
+
+		std::string_view debug_name() const {
+			const char* name = lauf_asm_global_debug_name(*this);
+			return name == nullptr ? std::string_view {} : name;
+		}
+
+		lauf_asm_layout layout() const {
+			return lauf_asm_global_layout(*this);
+		}
+
+		bool has_definition() const {
+			return lauf_asm_global_has_definition(*this);
+		}
+	};
+}