Add MSVC support

Author: Spartan322

include/lauf/config.h

@@ -52,6 +52,13 @@ typedef uint64_t lauf_uint;
 #    define LAUF_NOINLINE [[gnu::noinline]]
 #    define LAUF_FORCE_INLINE [[gnu::always_inline]] inline
 #    define LAUF_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+#    define LAUF_LIKELY(Cond) (Cond)
+#    define LAUF_UNLIKELY(Cond) (Cond)
+#    define LAUF_TAIL_CALL
+#    define LAUF_NOINLINE __declspec(noinline)
+#    define LAUF_FORCE_INLINE __forceinline
+#    define LAUF_UNREACHABLE __assume(0)
 #endif
 
 //=== configurations ===//
@@ -70,6 +77,12 @@ typedef uint64_t lauf_uint;
         _Pragma("GCC diagnostic ignored \"-Wconversion\"");                                        \
         __VA_ARGS__;                                                                               \
         _Pragma("GCC diagnostic pop")
+#elif defined(_MSC_VER)
+#    define LAUF_BITFIELD_CONVERSION(...)                                                          \
+        _Pragma("warning(push)");                                                                  \
+        _Pragma("warning(disable : 4267)");                                                        \
+        __VA_ARGS__;                                                                               \
+        _Pragma("warning(pop)")
 #else
 #    define LAUF_BITFIELD_CONVERSION(...) __VA_ARGS__
 #endif

include/lauf/runtime/builtin.h

@@ -16,6 +16,8 @@ LAUF_HEADER_START
 #    endif
 #elif defined(__GNUC__) || defined(__GNUG__)
 #    define LAUF_RUNTIME_BUILTIN_IMPL __attribute__((section(".text.lauf_builtin"), aligned(8)))
+#elif defined(_MSC_VER)
+#    define LAUF_RUNTIME_BUILTIN_IMPL __declspec(code_seg(".text.lauf_builtin"))
 #else
 #    define LAUF_RUNTIME_BUILTIN_IMPL
 #endif

include/lauf/runtime/memory.h

@@ -12,6 +12,7 @@ typedef struct lauf_asm_function             lauf_asm_function;
 typedef struct lauf_asm_global               lauf_asm_global;
 typedef struct lauf_asm_layout               lauf_asm_layout;
 typedef struct lauf_asm_signature            lauf_asm_signature;
+typedef struct lauf_runtime_address_store    lauf_runtime_address_store;
 typedef struct lauf_runtime_address          lauf_runtime_address;
 typedef struct lauf_runtime_fiber            lauf_runtime_fiber;
 typedef struct lauf_runtime_function_address lauf_runtime_function_address;
@@ -35,7 +36,7 @@ const char* lauf_runtime_get_cstr(lauf_runtime_process* p, lauf_runtime_address
 
 /// Gets the address for a native pointer of the specified allocation.
 /// On success, updates `allocation` to the actual address.
-bool lauf_runtime_get_address(lauf_runtime_process* p, lauf_runtime_address* allocation,
+bool lauf_runtime_get_address(lauf_runtime_process* p, lauf_runtime_address_store* allocation,
                               const void* ptr);
 
 /// Returns the address of a global variable of the process.
@@ -132,7 +133,8 @@ bool lauf_runtime_unpoison_allocation(lauf_runtime_process* p, lauf_runtime_addr
 /// Existing addresses for `a` are only valid if their offset is `< o`; otherwise, they become
 /// invalidated. Neither `a` nor `a'` can be freed until the allocation has been merged again.
 bool lauf_runtime_split_allocation(lauf_runtime_process* p, lauf_runtime_address addr,
-                                   lauf_runtime_address* addr1, lauf_runtime_address* addr2);
+                                   lauf_runtime_address_store* addr1,
+                                   lauf_runtime_address_store* addr2);
 
 /// Merges an allocation that has been previously split.
 ///
@@ -162,4 +164,3 @@ bool lauf_runtime_undeclare_weak(lauf_runtime_process* p, lauf_runtime_address a
 LAUF_HEADER_END
 
 #endif // LAUF_RUNTIME_MEMORY_H_INCLUDED
-

include/lauf/runtime/value.h

@@ -8,19 +8,36 @@
 
 LAUF_HEADER_START
 
+typedef struct lauf_runtime_address_store
+{
+    uint64_t value;
+} lauf_runtime_address_store;
+
 typedef struct lauf_runtime_address
 {
     // Order of the fields chosen carefully:
     // acess to allocation is an AND, acess to offset a SHIFT, access to generation SHIFT + AND
     // (which is the one only necessary for checks). In addition, treating it as an integer and e.g.
     // incrementing it changes allocation first, not offset. That way, bugs are caught earlier.
     uint64_t allocation : 30;
-    uint64_t generation : 2;
-    uint64_t offset : 32;
+    uint32_t generation : 2;
+    uint32_t offset;
 } lauf_runtime_address;
 
 static const lauf_runtime_address lauf_runtime_address_null = {0x3FFFFFFF, 0x3, 0xFFFFFFFF};
 
+lauf_runtime_address lauf_runtime_address_from_store(lauf_runtime_address_store addr);
+
+lauf_runtime_address_store lauf_runtime_address_to_store(lauf_runtime_address addr);
+
+void lauf_runtime_address_store_set_allocation(lauf_runtime_address_store* store,
+                                               uint32_t                    allocation);
+
+void lauf_runtime_address_store_set_generation(lauf_runtime_address_store* store,
+                                               uint8_t                     generation);
+
+void lauf_runtime_address_store_set_offset(lauf_runtime_address_store* store, uint32_t offset);
+
 typedef struct lauf_runtime_function_address
 {
     uint16_t index;
@@ -36,11 +53,10 @@ typedef union lauf_runtime_value
     lauf_uint                     as_uint;
     lauf_sint                     as_sint;
     void*                         as_native_ptr;
-    lauf_runtime_address          as_address;
+    lauf_runtime_address_store    as_address;
     lauf_runtime_function_address as_function_address;
 } lauf_runtime_value;
 
 LAUF_HEADER_END
 
 #endif // LAUF_RUNTIME_VALUE_H_INCLUDED
-

src/CMakeLists.txt

@@ -34,18 +34,30 @@ target_include_directories(lauf_core SYSTEM INTERFACE ../include)
 target_include_directories(lauf_core PRIVATE ../include .)
 target_link_libraries(lauf_core PRIVATE lauf_warnings foonathan::lexy)
 
-if(NOT LAUF_DISPATCH_JUMP_TABLE)
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+    if(NOT LAUF_DISPATCH_JUMP_TABLE)
+        messsage(WARNING "MSVC does not support disabling of jump tables")
+    endif()
+elseif(NOT LAUF_DISPATCH_JUMP_TABLE)
     target_compile_definitions(lauf_core PUBLIC LAUF_CONFIG_DISPATCH_JUMP_TABLE=0)
     target_compile_options(lauf_core PRIVATE -fno-jump-tables)
 endif()
 # Since we're using tail calls for dispatching, we don't want to add frame pointers, ever.
 # They would record all previously executed instructions in the call stack.
-target_compile_options(lauf_core PRIVATE -fomit-frame-pointer)
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+    target_compile_options(lauf_core PRIVATE /Oy)
+else()
+    target_compile_options(lauf_core PRIVATE -fomit-frame-pointer)
+endif()
 
 if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         target_compile_definitions(lauf_core PUBLIC LAUF_HAS_TAIL_CALL_ELIMINATION=0)
     endif()
+elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+        target_compile_definitions(lauf_core PUBLIC LAUF_HAS_TAIL_CALL_ELIMINATION=0)
+    endif()
 endif()
 
 target_sources(lauf_core PUBLIC
@@ -107,6 +119,7 @@ target_sources(lauf_core PRIVATE
                 ${src_dir}/runtime/process.cpp
                 ${src_dir}/runtime/stack.hpp
                 ${src_dir}/runtime/stacktrace.cpp
+                ${src_dir}/runtime/value.cpp
 
                 ${src_dir}/lib/bits.cpp
                 ${src_dir}/lib/debug.cpp

src/lauf/asm/builder.cpp

@@ -739,7 +739,7 @@ void lauf_asm_inst_call(lauf_asm_builder* b, const lauf_asm_function* callee)
 
     LAUF_BUILD_ASSERT(b->cur->vstack.pop(callee->sig.input_count), "missing input values for call");
 
-    auto offset = lauf::compress_pointer_offset(b->fn, callee);
+    auto offset = lauf::new_compress_pointer_offset(b->fn, callee);
     b->cur->insts.push_back(*b, LAUF_BUILD_INST_OFFSET(call, offset));
 
     b->cur->vstack.push_output(*b, callee->sig.output_count);
@@ -777,7 +777,7 @@ void lauf_asm_inst_call_indirect(lauf_asm_builder* b, lauf_asm_signature sig)
     if (auto callee = get_constant_function(b->mod, *fn_addr, sig))
     {
         add_pop_top_n(b, 1);
-        auto offset = lauf::compress_pointer_offset(b->fn, callee);
+        auto offset = lauf::new_compress_pointer_offset(b->fn, callee);
         b->cur->insts.push_back(*b, LAUF_BUILD_INST_OFFSET(call, offset));
     }
     else
@@ -793,7 +793,7 @@ namespace
 {
 void add_call_builtin(lauf_asm_builder* b, lauf_runtime_builtin_function callee)
 {
-    auto offset = lauf::compress_pointer_offset(&lauf_runtime_builtin_dispatch, callee.impl);
+    auto offset = lauf::new_compress_pointer_offset(&lauf_runtime_builtin_dispatch, callee.impl);
     if ((callee.flags & LAUF_RUNTIME_BUILTIN_NO_PROCESS) != 0
         && (callee.flags & LAUF_RUNTIME_BUILTIN_NO_PANIC) != 0)
         b->cur->insts.push_back(*b, LAUF_BUILD_INST_OFFSET(call_builtin_no_regs, offset));
@@ -1021,10 +1021,12 @@ void lauf_asm_inst_global_addr(lauf_asm_builder* b, const lauf_asm_global* globa
 
     b->cur->insts.push_back(*b, LAUF_BUILD_INST_VALUE(global_addr, global->allocation_idx));
     b->cur->vstack.push_constant(*b, [&] {
-        lauf_runtime_value result;
-        LAUF_BITFIELD_CONVERSION(result.as_address.allocation = global->allocation_idx);
-        result.as_address.offset     = 0;
-        result.as_address.generation = 0; // Always true for globals.
+        lauf_runtime_value   result;
+        lauf_runtime_address addr;
+        LAUF_BITFIELD_CONVERSION(addr.allocation = global->allocation_idx);
+        addr.offset       = 0;
+        addr.generation   = 0; // Always true for globals.
+        result.as_address = lauf_runtime_address_to_store(addr);
         return result;
     }());
 }
@@ -1048,7 +1050,7 @@ void lauf_asm_inst_function_addr(lauf_asm_builder* b, const lauf_asm_function* f
 {
     LAUF_BUILD_CHECK_CUR;
 
-    auto offset = lauf::compress_pointer_offset(b->fn, function);
+    auto offset = lauf::new_compress_pointer_offset(b->fn, function);
     b->cur->insts.push_back(*b, LAUF_BUILD_INST_OFFSET(function_addr, offset));
     b->cur->vstack.push_constant(*b, [&] {
         lauf_runtime_value result;
@@ -1288,7 +1290,7 @@ load_store_constant load_store_constant_folding(lauf_asm_module*            mod,
         // TOCTOU is okay, we just can't constant fold because of it.
         auto globals = lauf::get_globals(mod);
 
-        auto constant_addr = addr.as_constant.as_address;
+        auto constant_addr = lauf_runtime_address_from_store(addr.as_constant.as_address);
         if (constant_addr.allocation >= globals.count && constant_addr.generation != 0
             && constant_addr.offset != 0)
             return load_store_dynamic;
@@ -1330,8 +1332,10 @@ void lauf_asm_inst_load_field(lauf_asm_builder* b, lauf_asm_type type, size_t fi
     else if (constant_folding == load_store_global)
     {
         add_pop_top_n(b, 1);
-        b->cur->insts.push_back(*b, LAUF_BUILD_INST_VALUE(load_global_value,
-                                                          addr->as_constant.as_address.allocation));
+        b->cur->insts.push_back(       //
+            *b, LAUF_BUILD_INST_VALUE( //
+                    load_global_value,
+                    lauf_runtime_address_from_store(addr->as_constant.as_address).allocation));
         b->cur->vstack.push_output(*b, 1);
     }
     else if (type.layout.size == 0 && type.load_fn == nullptr)
@@ -1374,8 +1378,10 @@ void lauf_asm_inst_store_field(lauf_asm_builder* b, lauf_asm_type type, size_t f
     else if (constant_folding == load_store_global)
     {
         add_pop_top_n(b, 1);
-        b->cur->insts.push_back(*b, LAUF_BUILD_INST_VALUE(store_global_value,
-                                                          addr->as_constant.as_address.allocation));
+        b->cur->insts.push_back(       //
+            *b, LAUF_BUILD_INST_VALUE( //
+                    store_global_value,
+                    lauf_runtime_address_from_store(addr->as_constant.as_address).allocation));
         LAUF_BUILD_ASSERT(b->cur->vstack.pop(1), "missing value");
     }
     else if (type.layout.size == 0 && type.store_fn == nullptr)