Pass gcc

src/Native/natsu.fcall.cpp

@@ -1,5 +1,4 @@
 #include "Chino.Kernel.h"
-#include "System.Private.CorLib.h"
 #include <cmath>
 #include <cstring>
 

src/Native/natsu.gc.cpp

@@ -406,7 +406,7 @@ gc_obj_ref<Object> gc_alloc(const vtable_t &vtable, size_t size)
 #ifndef _WIN32
 extern "C"
 {
-    //void *__dso_handle = 0;
+    __attribute__((weak)) void *__dso_handle = 0;
 
     void *malloc(size_t n)
     {

src/Native/natsu.runtime.h

@@ -185,7 +185,7 @@ struct runtime_type_holder
 };
 
 template <class TFrom>
-auto stack_from(TFrom &&value);
+auto stack_from(const TFrom &value);
 
 template <class TTo, class TFrom>
 auto stack_to(TFrom &&value);
@@ -488,7 +488,7 @@ namespace stack
                     }
                     else
                     {
-                        return stack_from(obj);
+                        return obj;
                     }
                 }
                 else
@@ -579,9 +579,9 @@ namespace stack
         template <class TFrom, class TTo>
         struct access_impl<TFrom, gc_ref<TTo>>
         {
-            gc_ref<TTo> operator()(const TFrom &obj) const noexcept
+            gc_ref<TTo> operator()(TFrom &obj) const noexcept
             {
-                return gc_ref_from_ref(stack_to<TTo>(obj));
+                return gc_ref_from_ref(obj);
             }
         };
 
@@ -606,9 +606,9 @@ namespace stack
 }
 
 template <class TFrom>
-auto stack_from(TFrom &&value)
+auto stack_from(const TFrom &value)
 {
-    return stack::details::stack_from_impl<std::decay_t<TFrom>>()(std::forward<TFrom>(value));
+    return stack::details::stack_from_impl<std::decay_t<TFrom>>()(value);
 }
 
 template <class TTo, class TFrom>
@@ -620,7 +620,7 @@ auto stack_to(TFrom &&value)
 namespace ops
 {
 #define BINARY_OP_IMPL(name, op, A, B, Ret, Med, Cast)                                          \
-    inline Ret name(const A &lhs, const B &rhs) noexcept                                        \
+    inline Ret name##_(const A &lhs, const B &rhs) noexcept                                     \
     {                                                                                           \
         return static_cast<Cast>(static_cast<Med>(lhs.value_) op static_cast<Med>(rhs.value_)); \
     }
@@ -717,13 +717,13 @@ namespace ops
 
 #undef BINARY_OP_IMPL
 
-    inline stack::F rem(const stack::F &lhs, const stack::F &rhs) noexcept
+    inline stack::F rem_(const stack::F &lhs, const stack::F &rhs) noexcept
     {
         return fmod(lhs.value_, rhs.value_);
     }
 
 #define UNARY_OP_IMPL(name, op, A, Med, Cast)                        \
-    inline A name(const A &value) noexcept                           \
+    inline A name##_(const A &value) noexcept                        \
     {                                                                \
         return static_cast<Cast>(op static_cast<Med>(value.value_)); \
     }
@@ -736,7 +736,7 @@ namespace ops
 #undef UNARY_OP_IMPL
 
 #define COMPARE_OP_IMPL(name, op, A, B, Med)                                         \
-    inline stack::int32 name(const A &lhs, const B &rhs) noexcept                    \
+    inline stack::int32 name##_(const A &lhs, const B &rhs) noexcept                 \
     {                                                                                \
         return static_cast<Med>(lhs.value_) op static_cast<Med>(rhs.value_) ? 1 : 0; \
     }
@@ -889,9 +889,9 @@ namespace ops
     }
 
     template <class TTo, class TFrom>
-    auto access(TFrom value) noexcept
+    auto access(TFrom &&value) noexcept
     {
-        return stack::details::access_impl<TFrom, TTo>()(std::forward<TFrom>(value));
+        return stack::details::access_impl<std::decay_t<TFrom>, TTo>()(std::forward<TFrom>(value));
     }
 
     template <class TFrom>

src/Natsu.Compiler/ILImporter.cs

@@ -901,14 +901,14 @@ namespace Natsu.Compiler
                 Stack.Push(StackTypeCode.O, $"::natsu::ops::box(*::natsu::stack_to<{TypeUtils.EscapeVariableTypeName(new ByRefSig(Stack.Constrained.ToTypeSig()))}>({para[0].src.Expression}))");
                 para[0] = (para[0].destType, Stack.Pop());
 
-                expr = $"{para[0].src.Expression}.header().template vtable_as<{TypeUtils.EscapeTypeName(member.DeclaringType)}::VTable>()->{TypeUtils.EscapeMethodName(member)}({string.Join(", ", para.Select(x => CastExpression(x.destType, x.src)))})";
+                expr = $"{para[0].src.Expression}.header().template vtable_as<typename {TypeUtils.EscapeTypeName(member.DeclaringType)}::VTable>()->{TypeUtils.EscapeMethodName(member)}({string.Join(", ", para.Select(x => CastExpression(x.destType, x.src)))})";
 
                 Stack.Constrained = null;
             }
             else
             {
                 Writer.Ident(Ident).WriteLine($"::natsu::check_null_obj_ref({para[0].src.Expression});");
-                expr = $"{para[0].src.Expression}.header().template vtable_as<{TypeUtils.EscapeTypeName(member.DeclaringType)}::VTable>()->{TypeUtils.EscapeMethodName(member)}({string.Join(", ", para.Select(x => CastExpression(x.destType, x.src)))})";
+                expr = $"{para[0].src.Expression}.header().template vtable_as<typename {TypeUtils.EscapeTypeName(member.DeclaringType)}::VTable>()->{TypeUtils.EscapeMethodName(member)}({string.Join(", ", para.Select(x => CastExpression(x.destType, x.src)))})";
             }
 
             var stackType = TypeUtils.GetStackType(method.RetType);
@@ -981,14 +981,14 @@ namespace Natsu.Compiler
         public void Unary(string op)
         {
             var v1 = Stack.Pop();
-            Stack.Push(StackTypeCode.Int32, $"::natsu::ops::{op}({v1.Expression})");
+            Stack.Push(StackTypeCode.Int32, $"::natsu::ops::{op}_({v1.Expression})");
         }
 
         public void Binary(string op)
         {
             var v2 = Stack.Pop();
             var v1 = Stack.Pop();
-            Stack.Push(StackTypeCode.Int32, $"::natsu::ops::{op}({v1.Expression}, {v2.Expression})");
+            Stack.Push(StackTypeCode.Int32, $"::natsu::ops::{op}_({v1.Expression}, {v2.Expression})");
         }
 
         private void BranchUnconditional(int ident, Instruction op)
@@ -1001,7 +1001,7 @@ namespace Natsu.Compiler
             var v2 = Stack.Pop();
             var v1 = Stack.Pop();
             var nextOp = (Instruction)Op.Operand;
-            Writer.Ident(Ident).WriteLine($"if (::natsu::ops::{op}({v1.Expression}, {v2.Expression}).istrue())");
+            Writer.Ident(Ident).WriteLine($"if (::natsu::ops::{op}_({v1.Expression}, {v2.Expression}).istrue())");
             Writer.Ident(Ident + 1).WriteLine($"goto {ILUtils.GetLabel(Method, nextOp, Block)};");
             Writer.Ident(Ident).WriteLine("else");
             Writer.Ident(Ident + 1).WriteLine($"goto {ILUtils.GetFallthroughLabel(Method, Op, Block)};");