Add GCC support

Add MSVC support
OpenVicProject · Jul 21, 2024 · 227931a · 227931a
1 parent ff04b07
commit 227931a
Show file tree

Hide file tree

Showing 19 changed files with 198 additions and 109 deletions.
diff --git a/include/lauf/config.h b/include/lauf/config.h
@@ -36,22 +36,61 @@ typedef uint64_t lauf_uint;
 #    error "lauf assumes 8 bit bytes"
 #endif
 
-#if !defined(__clang__)
+/* #if !defined(__clang__)
 #    error "lauf currently requires clang"
-#endif
+#endif */
 
 //=== optimizations ===//
-#define LAUF_LIKELY(Cond) __builtin_expect((Cond), 1)
-#define LAUF_UNLIKELY(Cond) __builtin_expect((Cond), 0)
-#define LAUF_TAIL_CALL [[clang::musttail]]
-#define LAUF_NOINLINE [[gnu::noinline]]
-#define LAUF_FORCE_INLINE [[gnu::always_inline]]
-#define LAUF_UNREACHABLE __builtin_unreachable()
+#define LAUF_LIKELY(Cond) Cond   /*__builtin_expect((Cond), 1)*/
+#define LAUF_UNLIKELY(Cond) Cond /*__builtin_expect((Cond), 0)*/
+#if defined(__clang__)
+#    define LAUF_TAIL_CALL [[clang::musttail]]
+#elif defined(__GNUC__) || defined(__GNUG__)
+#    define LAUF_TAIL_CALL
+#endif
+#if defined(_MSC_VER)
+#    define LAUF_NOINLINE __declspec(noinline)
+#    define LAUF_FORCE_INLINE __forceinline
+#    define LAUF_UNREACHABLE __assume(0)
+#else
+#    define LAUF_NOINLINE [[gnu::noinline]]
+#    define LAUF_FORCE_INLINE [[gnu::always_inline]] inline
+#    define LAUF_UNREACHABLE __builtin_unreachable()
+#endif
 
 //=== configurations ===//
 #ifndef LAUF_CONFIG_DISPATCH_JUMP_TABLE
 #    define LAUF_CONFIG_DISPATCH_JUMP_TABLE 1
 #endif
 
-#endif // LAUF_CONFIG_H_INCLUDED
+#if !defined(__clang__) && (defined(__GNUC__) || defined(__GNUG__))
+#    define LAUF_IGNORE_BITFIELD_WARNING(...)                                                      \
+        _Pragma("GCC diagnostic push");                                                            \
+        _Pragma("GCC diagnostic ignored \"-Wconversion\"");                                        \
+        __VA_ARGS__;                                                                               \
+        _Pragma("GCC diagnostic pop");
+#else
+#    define LAUF_IGNORE_BITFIELD_WARNING(...) __VA_ARGS__
+#endif
 
+#if !defined(__clang__) && (defined(__GNUC__) || defined(__GNUG__))
+#    define LAUF_IGNORE_CONV_WARNING(...)                                                          \
+        _Pragma("GCC diagnostic push");                                                            \
+        _Pragma("GCC diagnostic ignored \"-Wconversion\"");                                        \
+        __VA_ARGS__;                                                                               \
+        _Pragma("GCC diagnostic pop");
+#else
+#    define LAUF_IGNORE_CONV_WARNING(...) __VA_ARGS__
+#endif
+
+#if !defined(__clang__) && (defined(__GNUC__) || defined(__GNUG__))
+#    define LAUF_IGNORE_SIGN_WARNING(...)                                                          \
+        _Pragma("GCC diagnostic push");                                                            \
+        _Pragma("GCC diagnostic ignored \"-Wsign-conversion\"");                                   \
+        __VA_ARGS__;                                                                               \
+        _Pragma("GCC diagnostic pop");
+#else
+#    define LAUF_IGNORE_SIGN_WARNING(...) __VA_ARGS__
+#endif
+
+#endif // LAUF_CONFIG_H_INCLUDED
diff --git a/include/lauf/runtime/builtin.h b/include/lauf/runtime/builtin.h
@@ -8,7 +8,11 @@
 
 LAUF_HEADER_START
 
+#if defined(__clang__)
 #define LAUF_RUNTIME_BUILTIN_IMPL __attribute__((section("text.lauf_builtin"), aligned(8)))
+#else
+#define LAUF_RUNTIME_BUILTIN_IMPL
+#endif
 
 typedef union lauf_asm_inst             lauf_asm_inst;
 typedef struct lauf_asm_type            lauf_asm_type;

diff --git a/src/lauf/asm/builder.cpp b/src/lauf/asm/builder.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: BSL-1.0
 
 #include <lauf/asm/builder.hpp>
+#include <lauf/config.h>
 
 #include <cstdio>
 #include <cstdlib>
@@ -372,7 +373,7 @@ LAUF_NOINLINE lauf_asm_inst* emit_body(lauf_asm_inst* ip, lauf_asm_builder* b,
         assert(insts[dest->offset].op() == lauf::asm_op::block);
         auto dest_offset = dest->offset + 1;
 
-        jump->jump.offset = std::int32_t(dest_offset - cur_offset);
+        LAUF_IGNORE_BITFIELD_WARNING(jump->jump.offset = std::int32_t(dest_offset - cur_offset));
     }
 
     return ip;
@@ -437,7 +438,7 @@ void emit_debug_location(lauf_asm_builder* b)
             for (auto loc : block.debug_locations)
             {
                 // We also have the initial block instruction that affects the inst_idx.
-                loc.inst_idx += block.offset + 1;
+                LAUF_IGNORE_CONV_WARNING(loc.inst_idx += block.offset + 1);
                 cont.push_back(arena, loc);
             }
         }
@@ -541,7 +542,7 @@ lauf_asm_local* lauf_asm_build_local(lauf_asm_builder* b, lauf_asm_layout layout
 
         // The offset is the current size, we don't need to worry about alignment.
         offset = std::uint16_t(b->local_allocation_size + sizeof(lauf_runtime_stack_frame));
-        b->local_allocation_size += layout.size;
+        LAUF_IGNORE_CONV_WARNING(b->local_allocation_size += layout.size);
     }
     else
     {
@@ -553,7 +554,7 @@ lauf_asm_local* lauf_asm_build_local(lauf_asm_builder* b, lauf_asm_layout layout
         // for a pointer.
         //  Since `layout.alignment` is a multiple of it (as a power of two bigger than it), and
         //  size a multiple of alignment, `layout.alignment + layout.size` is as well.
-        b->local_allocation_size += layout.alignment + layout.size;
+        LAUF_IGNORE_CONV_WARNING(b->local_allocation_size += layout.alignment + layout.size);
         // Since we don't know the exact alignment offset, we can't compute it statically.
         offset = UINT16_MAX;
     }
@@ -1006,7 +1007,7 @@ 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;
-        result.as_address.allocation = global->allocation_idx;
+        LAUF_IGNORE_BITFIELD_WARNING(result.as_address.allocation = global->allocation_idx);
         result.as_address.offset     = 0;
         result.as_address.generation = 0; // Always true for globals.
         return result;
@@ -1381,4 +1382,3 @@ void lauf_asm_inst_store_field(lauf_asm_builder* b, lauf_asm_type type, size_t f
         lauf_asm_inst_call_builtin(b, builtin);
     }
 }
-
diff --git a/src/lauf/asm/builder.hpp b/src/lauf/asm/builder.hpp
@@ -282,7 +282,7 @@ struct lauf_asm_builder : lauf::intrinsic_arena<lauf_asm_builder>
 #define LAUF_BUILD_INST_OFFSET(Name, Offset)                                                       \
     [&](const char* context, std::ptrdiff_t offset) {                                              \
         lauf_asm_inst result;                                                                      \
-        result.Name = {lauf::asm_op::Name, std::int32_t(offset)};                                  \
+        LAUF_IGNORE_BITFIELD_WARNING(result.Name = {lauf::asm_op::Name, std::int32_t(offset)});    \
         if (result.Name.offset != offset)                                                          \
             b->error(context, "offset too big");                                                   \
         return result;                                                                             \
@@ -315,7 +315,7 @@ struct lauf_asm_builder : lauf::intrinsic_arena<lauf_asm_builder>
 #define LAUF_BUILD_INST_VALUE(Name, Value)                                                         \
     [&](const char* context, std::size_t value) {                                                  \
         lauf_asm_inst result;                                                                      \
-        result.Name = {lauf::asm_op::Name, std::uint32_t(value)};                                  \
+        LAUF_IGNORE_BITFIELD_WARNING(result.Name = {lauf::asm_op::Name, std::uint32_t(value)});    \
         if (value != result.Name.value)                                                            \
             b->error(context, "invalid value");                                                    \
         return result;                                                                             \
@@ -331,4 +331,3 @@ struct lauf_asm_builder : lauf::intrinsic_arena<lauf_asm_builder>
     }(LAUF_BUILD_ASSERT_CONTEXT, Index)
 
 #endif // SRC_LAUF_ASM_BUILDER_HPP_INCLUDED
-
diff --git a/src/lauf/backend/qbe.hpp b/src/lauf/backend/qbe.hpp
@@ -5,12 +5,15 @@
 #define SRC_LAUF_BACKEND_QBE_HPP_INCLUDED
 
 #include <lauf/backend/qbe.h>
+#include <lauf/config.h>
 
 #include <cinttypes>
 #include <lauf/writer.hpp>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <variant>
 
 namespace lauf
@@ -80,6 +83,12 @@ enum class qbe_cc
 
 class qbe_writer
 {
+    template <class Enum>
+    constexpr std::underlying_type_t<Enum> to_underlying(Enum e) noexcept
+    {
+        return static_cast<std::underlying_type_t<Enum>>(e);
+    }
+
 public:
     qbe_writer() : _writer(lauf_create_string_writer()) {}
 
@@ -90,7 +99,7 @@ class qbe_writer
     {
         for (auto& [str, id] : _literals)
         {
-            out->format("data $lit_%u = {", static_cast<unsigned>(id));
+            out->format("data $lit_%u = {", to_underlying(id));
             for (auto c : str)
                 out->format("b %d, ", c);
             out->write("}\n");
@@ -123,7 +132,7 @@ class qbe_writer
     //=== data ===//
     void begin_data(qbe_data id, std::size_t alignment)
     {
-        _writer->format("data $data_%u = align %zu\n", static_cast<unsigned>(id), alignment);
+        _writer->format("data $data_%u = align %zu\n", to_underlying(id), alignment);
         _writer->write("{\n");
     }
 
@@ -157,8 +166,8 @@ class qbe_writer
         else if (std::holds_alternative<qbe_type>(ty))
             _writer->format("function %s $%s(", type_name(std::get<qbe_type>(ty)), name);
         else
-            _writer->format("function :tuple_%u $%s(",
-                            static_cast<unsigned>(std::get<qbe_tuple>(ty)), name);
+            _writer->format("function :tuple_%u $%s(", to_underlying(std::get<qbe_tuple>(ty)),
+                            name);
     }
 
     void param(qbe_type ty, std::size_t idx)
@@ -175,7 +184,7 @@ class qbe_writer
 
     void block(qbe_block id)
     {
-        _writer->format("@block_%zu\n", static_cast<std::size_t>(id));
+        _writer->format("@block_%zu\n", to_underlying(id));
     }
 
     void end_function()
@@ -188,15 +197,14 @@ class qbe_writer
     //=== instructions ===//
     void jmp(qbe_block block)
     {
-        _writer->format("  jmp @block_%zu\n", static_cast<std::size_t>(block));
+        _writer->format("  jmp @block_%zu\n", to_underlying(block));
     }
 
     void jnz(qbe_reg reg, qbe_block block1, qbe_block block2)
     {
         _writer->write("  jnz ");
         write_reg(reg);
-        _writer->format(", @block_%zu, @block_%zu\n", static_cast<std::size_t>(block1),
-                        static_cast<std::size_t>(block2));
+        _writer->format(", @block_%zu, @block_%zu\n", to_underlying(block1), to_underlying(block2));
     }
 
     void ret()
@@ -348,7 +356,7 @@ class qbe_writer
         else
         {
             write_reg(dest);
-            _writer->format(" =:tuple_%u call ", static_cast<unsigned>(std::get<qbe_tuple>(ty)));
+            _writer->format(" =:tuple_%u call ", to_underlying(std::get<qbe_tuple>(ty)));
         }
 
         write_value(fn);
@@ -380,7 +388,7 @@ class qbe_writer
         if (a == qbe_alloc::return_)
             _writer->write("%return");
         else
-            _writer->format("%%a%u", static_cast<unsigned>(a));
+            _writer->format("%%a%u", to_underlying(a));
     }
 
     void write_reg(qbe_reg reg)
@@ -390,7 +398,7 @@ class qbe_writer
         else if (reg == qbe_reg::tmp2)
             _writer->write("%tmp2");
         else
-            _writer->format("%%r%u", static_cast<unsigned>(reg));
+            _writer->format("%%r%u", to_underlying(reg));
     }
 
     void write_value(const qbe_value& value)
@@ -402,9 +410,9 @@ class qbe_writer
         else if (std::holds_alternative<std::uintmax_t>(value))
             _writer->format("%" PRIuMAX, std::get<std::uintmax_t>(value));
         else if (std::holds_alternative<qbe_data>(value))
-            _writer->format("$data_%u", static_cast<unsigned>(std::get<qbe_data>(value)));
+            _writer->format("$data_%u", to_underlying(std::get<qbe_data>(value)));
         else if (std::holds_alternative<qbe_literal>(value))
-            _writer->format("$lit_%u", static_cast<unsigned>(std::get<qbe_literal>(value)));
+            _writer->format("$lit_%u", to_underlying(std::get<qbe_literal>(value)));
         else
             _writer->format("$%s", std::get<const char*>(value));
     }
@@ -425,6 +433,8 @@ class qbe_writer
             return "b";
         case qbe_type::halfword:
             return "h";
+        default:
+            LAUF_UNREACHABLE;
         }
     }
 
@@ -452,6 +462,8 @@ class qbe_writer
             return "uge";
         case qbe_cc::ugt:
             return "ugt";
+        default:
+            LAUF_UNREACHABLE;
         }
     }
 
@@ -462,4 +474,3 @@ class qbe_writer
 } // namespace lauf
 
 #endif // SRC_LAUF_BACKEND_QBE_HPP_INCLUDED
-
diff --git a/src/lauf/frontend/text.cpp b/src/lauf/frontend/text.cpp
@@ -670,8 +670,10 @@ struct location
     static constexpr auto rule  = dsl::position;
     static constexpr auto value = callback([](parse_state& state, auto pos) {
         auto loc = lexy::get_input_location(state.input->buffer, pos, state.anchor);
-        lauf_asm_build_debug_location(state.builder, {0, std::uint16_t(loc.line_nr()),
-                                                      std::uint16_t(loc.column_nr()), false, 0});
+        LAUF_IGNORE_BITFIELD_WARNING(
+            lauf_asm_build_debug_location(state.builder,
+                                          {0, std::uint16_t(loc.line_nr()),
+                                           std::uint16_t(loc.column_nr()), false, 0}));
         state.anchor = loc.anchor();
     });
 };
@@ -846,4 +848,3 @@ lauf_asm_module* lauf_frontend_text(lauf_reader* reader, lauf_frontend_text_opti
 
     return state.mod;
 }
-
diff --git a/src/lauf/lib/bits.cpp b/src/lauf/lib/bits.cpp
@@ -51,7 +51,7 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_bits_shl, 2, 1, panic_flags, "shl", &lauf_lib_bits
     auto n = vstack_ptr[0].as_uint;
     ++vstack_ptr;
 
-    if (LAUF_UNLIKELY(n >= sizeof(lauf_uint) * CHAR_BIT))
+    if (LAUF_UNLIKELY(n >= sizeof(lauf_uint) * CHAR_BIT)) [[unlikely]]
         return lauf_runtime_panic(process, "shift amount too big");
 
     vstack_ptr[0].as_uint = x << n;
@@ -64,7 +64,7 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_bits_ushr, 2, 1, panic_flags, "ushr", &lauf_lib_bi
     auto n = vstack_ptr[0].as_uint;
     ++vstack_ptr;
 
-    if (LAUF_UNLIKELY(n >= sizeof(lauf_uint) * CHAR_BIT))
+    if (LAUF_UNLIKELY(n >= sizeof(lauf_uint) * CHAR_BIT)) [[unlikely]]
         return lauf_runtime_panic(process, "shift amount too big");
 
     vstack_ptr[0].as_uint = x >> n;
@@ -77,7 +77,7 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_bits_sshr, 2, 1, panic_flags, "sshr", &lauf_lib_bi
     auto n = vstack_ptr[0].as_uint;
     ++vstack_ptr;
 
-    if (LAUF_UNLIKELY(n >= sizeof(lauf_sint) * CHAR_BIT))
+    if (LAUF_UNLIKELY(n >= sizeof(lauf_sint) * CHAR_BIT)) [[unlikely]]
         return lauf_runtime_panic(process, "shift amount too big");
 
     static_assert(-1 >> 1 == -1, "compiler does not implement arithmetic right shift");
@@ -86,4 +86,3 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_bits_sshr, 2, 1, panic_flags, "sshr", &lauf_lib_bi
 }
 
 const lauf_runtime_builtin_library lauf_lib_bits = {"lauf.bits", &lauf_lib_bits_sshr, nullptr};
-
diff --git a/src/lauf/lib/debug.cpp b/src/lauf/lib/debug.cpp
@@ -140,7 +140,27 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_debug_break, 0, 0,
                      LAUF_RUNTIME_BUILTIN_NO_PROCESS | LAUF_RUNTIME_BUILTIN_NO_PANIC, "break",
                      &lauf_lib_debug_print_all_cstacks)
 {
+#if __has_builtin(__builtin_debugtrap)
     __builtin_debugtrap();
+#elif __has_builtin(__debugbreak)
+    __debugbreak();
+#elif defined(_MSC_VER)
+    __debugbreak();
+#elif defined(__ARMCC_VERSION)
+    __breakpoint(42)
+#elif defined(__i386__) || defined(__x86_64__)
+    __asm__ __volatile__("int3");
+#elif defined(__thumb__)
+    __asm__ __volatile__(".inst 0xde01");
+#elif defined(__aarch64__)
+    __asm__ __volatile__(".inst 0xd4200000");
+#elif defined(__arm__)
+    __asm__ __volatile__(".inst 0xe7f001f0");
+#elif defined(__clang__)
+    __builtin_debugtrap();
+#elif defined(__STDC_HOSTED__) && (__STDC_HOSTED__ == 0) && defined(__GNUC__)
+    __builtin_trap();
+#endif
     LAUF_RUNTIME_BUILTIN_DISPATCH;
 }
 
@@ -157,4 +177,3 @@ LAUF_RUNTIME_BUILTIN(lauf_lib_debug_read, 0, 1,
 }
 
 const lauf_runtime_builtin_library lauf_lib_debug = {"lauf.debug", &lauf_lib_debug_read, nullptr};
-