diff --git a/.clang-format b/.clang-format index 7660ed5b..0a8f9164 100644 --- a/.clang-format +++ b/.clang-format @@ -4,7 +4,7 @@ AccessModifierOffset: -4 AllowShortFunctionsOnASingleLine: false AllowShortLambdasOnASingleLine: Inline AlwaysBreakTemplateDeclarations: Yes -ColumnLimit: 240 +ColumnLimit: 120 CompactNamespaces: true IncludeBlocks: Merge IncludeCategories: diff --git a/nautilus/include/nautilus/Engine.hpp b/nautilus/include/nautilus/Engine.hpp index 2388364d..4943d119 100644 --- a/nautilus/include/nautilus/Engine.hpp +++ b/nautilus/include/nautilus/Engine.hpp @@ -32,7 +32,7 @@ std::function createFunctionWrapper(std::index_sequence, std auto traceFunc = [=]() { if constexpr (std::is_void_v) { func(details::createTraceableArgument()...); - tracing::traceReturnOperation(Type::v, tracing::value_ref()); + tracing::traceReturnOperation(Type::v, tracing::TypedValueRef()); } else { auto returnValue = func(details::createTraceableArgument()...); auto type = tracing::to_type(); diff --git a/nautilus/include/nautilus/function.hpp b/nautilus/include/nautilus/function.hpp index d9ab2584..2e37f1bd 100644 --- a/nautilus/include/nautilus/function.hpp +++ b/nautilus/include/nautilus/function.hpp @@ -10,10 +10,10 @@ namespace nautilus { template auto getArgumentReferences(const ValueArguments&... arguments) { - std::vector functionArgumentReferences; + std::vector functionArgumentReferences; if constexpr (sizeof...(ValueArguments) > 0) { functionArgumentReferences.reserve(sizeof...(ValueArguments)); - for (const tracing::value_ref& p : {details::getState(arguments)...}) { + for (const tracing::TypedValueRef& p : {details::getState(arguments)...}) { functionArgumentReferences.emplace_back(p); } } diff --git a/nautilus/include/nautilus/std/string.h b/nautilus/include/nautilus/std/string.h index f13300c5..0c90cdb7 100644 --- a/nautilus/include/nautilus/std/string.h +++ b/nautilus/include/nautilus/std/string.h @@ -115,7 +115,8 @@ class val> { } /** - * Informs a std::basic_string object of a planned change in size, so that it can manage the storage allocation appropriately. + * Informs a std::basic_string object of a planned change in size, so that it can manage the storage allocation + * appropriately. * @param new_cap */ void reserve(val new_cap) const { @@ -147,7 +148,8 @@ class val> { */ auto& insert(val index, val count, val ch) const { invoke( - +[](base_type* ptr, size_type index, size_type count, CharT ch) -> void { ptr->insert(index, count, ch); }, data_ptr, index, count, ch); + +[](base_type* ptr, size_type index, size_type count, CharT ch) -> void { ptr->insert(index, count, ch); }, + data_ptr, index, count, ch); return *this; } @@ -156,7 +158,8 @@ class val> { */ auto& insert(val index, val s) const { invoke( - +[](base_type* ptr, size_type index, const CharT* s) -> void { ptr->insert(index, s); }, data_ptr, index, s); + +[](base_type* ptr, size_type index, const CharT* s) -> void { ptr->insert(index, s); }, data_ptr, index, + s); return *this; } @@ -181,9 +184,13 @@ class val> { /** * Appends additional characters to the string. */ - auto& append(const val>& str, const val& pos, const val& count) { + auto& append(const val>& str, const val& pos, + const val& count) { invoke( - +[](base_type* ptr, base_type* other, size_type pos, size_type count) -> void { ptr->append(*other, pos, count); }, data_ptr, str.data_ptr, pos, count); + +[](base_type* ptr, base_type* other, size_type pos, size_type count) -> void { + ptr->append(*other, pos, count); + }, + data_ptr, str.data_ptr, pos, count); return *this; } @@ -192,7 +199,8 @@ class val> { */ auto& append(const val>& str, const val& count) { invoke( - +[](base_type* ptr, base_type* other, size_type count) -> void { ptr->append(*other, count); }, data_ptr, str.data_ptr, count); + +[](base_type* ptr, base_type* other, size_type count) -> void { ptr->append(*other, count); }, data_ptr, + str.data_ptr, count); return *this; } @@ -243,11 +251,15 @@ class val> { } /** - * Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts past the end of the string, or if count == npos, the copied substring is [pos, size()). + * Copies a substring [pos, pos + count) to character string pointed to by dest. If the requested substring lasts + * past the end of the string, or if count == npos, the copied substring is [pos, size()). */ val copy(const val& dest, const val& count, const val& pos = 0) { return invoke( - +[](base_type* ptr, CharT* dest, size_type count, size_type pos) -> size_type { return ptr->copy(dest, count, pos); }, data_ptr, dest, count, pos); + +[](base_type* ptr, CharT* dest, size_type count, size_type pos) -> size_type { + return ptr->copy(dest, count, pos); + }, + data_ptr, dest, count, pos); } ~val() { diff --git a/nautilus/include/nautilus/std/string_view.h b/nautilus/include/nautilus/std/string_view.h index 848324ef..c8d7ef63 100644 --- a/nautilus/include/nautilus/std/string_view.h +++ b/nautilus/include/nautilus/std/string_view.h @@ -62,12 +62,16 @@ class val> { val operator[](val pos) const { return invoke( - +[](std::basic_string_view* ptr, size_type pos) -> value_type { return ptr->operator[](pos); }, data_ptr, pos); + +[](std::basic_string_view* ptr, size_type pos) -> value_type { + return ptr->operator[](pos); + }, + data_ptr, pos); } const val at(val index) const { return invoke( - +[](std::basic_string_view* ptr, size_type index) -> value_type { return ptr->at(index); }, data_ptr, index); + +[](std::basic_string_view* ptr, size_type index) -> value_type { return ptr->at(index); }, + data_ptr, index); } val size() const noexcept { @@ -107,22 +111,30 @@ class val> { void remove_prefix(val n) { invoke( - +[](std::basic_string_view* ptr, size_type n) -> void { ptr->remove_prefix(n); }, data_ptr, n); + +[](std::basic_string_view* ptr, size_type n) -> void { ptr->remove_prefix(n); }, data_ptr, + n); } void remove_suffix(val n) { invoke( - +[](std::basic_string_view* ptr, size_type n) -> void { ptr->remove_suffix(n); }, data_ptr, n); + +[](std::basic_string_view* ptr, size_type n) -> void { ptr->remove_suffix(n); }, data_ptr, + n); } void swap(val>& v) { invoke( - +[](std::basic_string_view* ptr, std::basic_string_view* other) -> void { ptr->swap(*other); }, data_ptr, v.data_ptr); + +[](std::basic_string_view* ptr, std::basic_string_view* other) -> void { + ptr->swap(*other); + }, + data_ptr, v.data_ptr); } val copy(val dest, val count, val pos = 0) { return invoke( - +[](std::basic_string_view* ptr, CharT* dest, size_type count, size_type pos) -> size_type { return ptr->copy(dest, count, pos); }, data_ptr, dest, count, pos); + +[](std::basic_string_view* ptr, CharT* dest, size_type count, size_type pos) -> size_type { + return ptr->copy(dest, count, pos); + }, + data_ptr, dest, count, pos); } /* @@ -142,76 +154,104 @@ class val> { val compare(val>& v) { return invoke( - +[](std::basic_string_view* ptr, std::basic_string_view* other) -> int { return ptr->compare(*other); }, data_ptr, v.data_ptr); + +[](std::basic_string_view* ptr, std::basic_string_view* other) -> int { + return ptr->compare(*other); + }, + data_ptr, v.data_ptr); } val compare(val pos1, val count1, val>& v) { return invoke( - +[](std::basic_string_view* ptr, size_type pos1, size_t count1, std::basic_string_view* v) -> int { return ptr->compare(pos1, count1, *v); }, data_ptr, pos1, count1, v.data_ptr); + +[](std::basic_string_view* ptr, size_type pos1, size_t count1, + std::basic_string_view* v) -> int { return ptr->compare(pos1, count1, *v); }, + data_ptr, pos1, count1, v.data_ptr); } - val compare(val pos1, val count1, val>& v, val pos2, val count2) { + val compare(val pos1, val count1, val>& v, + val pos2, val count2) { return invoke( - +[](std::basic_string_view* ptr, size_type pos1, size_t count1, std::basic_string_view* v, size_type pos2, size_t count2) -> int { return ptr->compare(pos1, count1, *v, pos2, count2); }, data_ptr, - pos1, count1, v.data_ptr, pos2, count2); + +[](std::basic_string_view* ptr, size_type pos1, size_t count1, + std::basic_string_view* v, size_type pos2, + size_t count2) -> int { return ptr->compare(pos1, count1, *v, pos2, count2); }, + data_ptr, pos1, count1, v.data_ptr, pos2, count2); } val compare(val s) { return invoke( - +[](std::basic_string_view* ptr, const CharT* s) -> int { return ptr->compare(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, const CharT* s) -> int { return ptr->compare(s); }, + data_ptr, s); } val compare(val pos1, val count1, val s) { return invoke( - +[](std::basic_string_view* ptr, size_type pos1, size_t count1, const CharT* s) -> int { return ptr->compare(pos1, count1, s); }, data_ptr, pos1, count1, s); + +[](std::basic_string_view* ptr, size_type pos1, size_t count1, const CharT* s) -> int { + return ptr->compare(pos1, count1, s); + }, + data_ptr, pos1, count1, s); } - val compare(val pos1, val count1, val s, val pos2, val count2) { + val compare(val pos1, val count1, val s, val pos2, + val count2) { return invoke( - +[](std::basic_string_view* ptr, size_type pos1, size_t count1, const CharT* s, size_type pos2, size_t count2) -> int { return ptr->compare(pos1, count1, s, pos2, count2); }, data_ptr, pos1, count1, s, pos2, - count2); + +[](std::basic_string_view* ptr, size_type pos1, size_t count1, const CharT* s, + size_type pos2, size_t count2) -> int { return ptr->compare(pos1, count1, s, pos2, count2); }, + data_ptr, pos1, count1, s, pos2, count2); } #ifdef __cpp_lib_starts_ends_with val start_with(val>& v) { return invoke( - +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { return ptr->starts_with(*v); }, data_ptr, v.data_ptr); + +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { + return ptr->starts_with(*v); + }, + data_ptr, v.data_ptr); } val start_with(val s) { return invoke( - +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->starts_with(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->starts_with(s); }, + data_ptr, s); } val start_with(val s) { return invoke( - +[](std::basic_string_view* ptr, CharT s) -> bool { return ptr->starts_with(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, CharT s) -> bool { return ptr->starts_with(s); }, data_ptr, + s); } val end_with(val>& v) { return invoke( - +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { return ptr->ends_with(*v); }, data_ptr, v.data_ptr); + +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { + return ptr->ends_with(*v); + }, + data_ptr, v.data_ptr); } val end_with(val s) { return invoke( - +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->ends_with(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->ends_with(s); }, + data_ptr, s); } val end_with(val s) { return invoke( - +[](std::basic_string_view* ptr, CharT s) -> bool { return ptr->ends_with(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, CharT s) -> bool { return ptr->ends_with(s); }, data_ptr, + s); } #endif #ifdef __cpp_lib_string_contains val contains(val>& v) { return invoke( - +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { return ptr->contains(*v); }, data_ptr, v.data_ptr); + +[](std::basic_string_view* ptr, std::basic_string_view* v) -> bool { + return ptr->contains(*v); + }, + data_ptr, v.data_ptr); } val contains(val s) { return invoke( - +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->contains(s); }, data_ptr, s); + +[](std::basic_string_view* ptr, const CharT* s) -> bool { return ptr->contains(s); }, + data_ptr, s); } val contains(val s) { diff --git a/nautilus/include/nautilus/tracing/TracingUtil.hpp b/nautilus/include/nautilus/tracing/TracingUtil.hpp index 7880f4e0..b6a1def0 100644 --- a/nautilus/include/nautilus/tracing/TracingUtil.hpp +++ b/nautilus/include/nautilus/tracing/TracingUtil.hpp @@ -15,32 +15,28 @@ namespace nautilus::tracing { bool inTracer(); -value_ref traceBinaryOp(Op operation, Type resultType, const TypedValueRef& leftState, const TypedValueRef& rightState); -value_ref traceUnaryOp(Op operation, Type resultType, const TypedValueRef& inputState); +TypedValueRef& traceBinaryOp(Op operation, Type resultType, const TypedValueRef& leftState, const TypedValueRef& rightState); +TypedValueRef& traceUnaryOp(Op operation, Type resultType, const TypedValueRef& inputState); bool traceBool(const TypedValueRef& state); -value_ref traceConstant(Type type, const ConstantLiteral& value); +TypedValueRef& traceConstant(Type type, const ConstantLiteral& value); template -value_ref traceConstant(T&& value) { +TypedValueRef traceConstant(T&& value) { if (inTracer()) { return traceConstant(to_type(), createConstLiteral(value)); } return {0, to_type()}; } -value_ref traceLoad(const TypedValueRef& src, Type resultType); -void traceStore(const TypedValueRef& target, const TypedValueRef& src, Type valueType); - -value_ref traceCast(const value_ref& state, Type resultType); void traceAssignment(const TypedValueRef& target, const TypedValueRef& source, Type resultType); -value_ref traceCopy(const TypedValueRef& state); +TypedValueRef traceCopy(const TypedValueRef& state); -value_ref traceCall(void* fptn, Type resultType, const std::vector& arguments); +TypedValueRef& traceCall(void* fptn, Type resultType, const std::vector& arguments); -value_ref registerFunctionArgument(Type type, size_t index); +TypedValueRef& registerFunctionArgument(Type type, size_t index); -void traceReturnOperation(Type type, const value_ref& ref); -void traceValueDestruction(value_ref ref); +void traceReturnOperation(Type type, const TypedValueRef& ref); +void traceValueDestruction(TypedValueRef ref); void pushStaticVal(void* ptr); void popStaticVal(); diff --git a/nautilus/include/nautilus/tracing/TypedValueRef.hpp b/nautilus/include/nautilus/tracing/TypedValueRef.hpp index 42f13a90..e8be57d8 100644 --- a/nautilus/include/nautilus/tracing/TypedValueRef.hpp +++ b/nautilus/include/nautilus/tracing/TypedValueRef.hpp @@ -49,5 +49,4 @@ class TypedValueRefHolder { TypedValueRef valueRef; }; -using value_ref = TypedValueRef; } // namespace nautilus::tracing diff --git a/nautilus/include/nautilus/val.hpp b/nautilus/include/nautilus/val.hpp index c2bf5334..2e9d57b2 100644 --- a/nautilus/include/nautilus/val.hpp +++ b/nautilus/include/nautilus/val.hpp @@ -17,12 +17,14 @@ namespace details { template LHS getRawValue(const val& val); -#define COMMON_RETURN_TYPE val::basic_type, typename std::remove_cvref_t::basic_type>::type> +#define COMMON_RETURN_TYPE \ + val::basic_type, \ + typename std::remove_cvref_t::basic_type>::type> #define DEDUCT_RETURN_TYPE(OP) val template -tracing::value_ref getState(T&& value) { +tracing::TypedValueRef getState(T&& value) { return value.state; } @@ -48,7 +50,7 @@ class val { // move constructor val(const val&& other) noexcept : state(std::move(other.state)), value(other.value) { } - val(tracing::value_ref& tc) : state(tc), value() { + val(tracing::TypedValueRef& tc) : state(tc), value() { } #else val() { @@ -79,7 +81,7 @@ class val { // cast if SHOULD_TRACE () { #ifdef ENABLE_TRACING - auto resultRef = tracing::traceCast(state, tracing::to_type()); + auto resultRef = tracing::traceUnaryOp(tracing::CAST, tracing::to_type(), state); return val(resultRef); #endif } @@ -145,7 +147,7 @@ class val { // move constructor val(const val&& other) : state(other.state), value(other.value) { } - val(tracing::value_ref& tc) : state(tc) { + val(tracing::TypedValueRef& tc) : state(tc) { } #else @@ -231,27 +233,29 @@ auto&& cast_value(LeftType&& value) { namespace details { #ifdef ENABLE_TRACING -#define TRAC_LOGICAL_BINARY_OP(OP) \ - if (tracing::inTracer()) { \ - auto tc = tracing::traceBinaryOp(lValue.state, rValue.state); \ - return val(tc); \ +#define TRAC_LOGICAL_BINARY_OP(OP) \ + if (tracing::inTracer()) { \ + auto tc = tracing::traceBinaryOp(lValue.state, rValue.state); \ + return val(tc); \ } #else #define TRAC_LOGICAL_BINARY_OP(OP) #endif -#define DEFINE_BINARY_OPERATOR_HELPER(OP, OP_NAME, OP_TRACE, RES_TYPE) \ - template \ - auto inline OP_NAME(LHS&& left, RHS&& right) { \ - typedef typename std::common_type::basic_type, typename std::remove_reference_t::basic_type>::type commonType; \ - auto&& lValue = cast_value(std::forward(left)); \ - auto&& rValue = cast_value(std::forward(right)); \ - using resultType = decltype(getRawValue(lValue) OP getRawValue(rValue)); \ - if SHOULD_TRACE () { \ - auto tc = tracing::traceBinaryOp(tracing::OP_TRACE, tracing::to_type(), details::getState(lValue), details::getState(rValue)); \ - return RES_TYPE(tc); \ - } \ - return RES_TYPE(getRawValue(lValue) OP getRawValue(rValue)); \ +#define DEFINE_BINARY_OPERATOR_HELPER(OP, OP_NAME, OP_TRACE, RES_TYPE) \ + template \ + auto inline OP_NAME(LHS&& left, RHS&& right) { \ + typedef typename std::common_type::basic_type, \ + typename std::remove_reference_t::basic_type>::type commonType; \ + auto&& lValue = cast_value(std::forward(left)); \ + auto&& rValue = cast_value(std::forward(right)); \ + using resultType = decltype(getRawValue(lValue) OP getRawValue(rValue)); \ + if SHOULD_TRACE () { \ + auto tc = tracing::traceBinaryOp(tracing::OP_TRACE, tracing::to_type(), \ + details::getState(lValue), details::getState(rValue)); \ + return RES_TYPE(tc); \ + } \ + return RES_TYPE(getRawValue(lValue) OP getRawValue(rValue)); \ } DEFINE_BINARY_OPERATOR_HELPER(+, add, ADD, COMMON_RETURN_TYPE) @@ -304,25 +308,25 @@ LHS inline getRawValue(const val& val) { } // namespace details -#define DEFINE_BINARY_OPERATOR(OP, FUNC, CON_VAL, CON_VALUE) \ - template \ - requires(CON_VAL && CON_VAL) \ - auto inline operator OP(LHS&& left, RHS&& right) { \ - return details::FUNC(std::move(left), std::move(right)); \ - } \ - \ - template \ - requires(CON_VAL && CON_VALUE) \ - auto inline operator OP(LHS&& left, RHS&& right) { \ - auto&& rhsV = make_value(std::forward(right)); \ - return details::FUNC(std::move(left), std::move(rhsV)); \ - } \ - \ - template \ - requires(CON_VALUE && CON_VAL) \ - auto inline operator OP(LHS&& left, RHS&& right) { \ - auto&& lhsV = make_value(std::forward(left)); \ - return details::FUNC(std::move(lhsV), std::move(right)); \ +#define DEFINE_BINARY_OPERATOR(OP, FUNC, CON_VAL, CON_VALUE) \ + template \ + requires(CON_VAL && CON_VAL) \ + auto inline operator OP(LHS&& left, RHS&& right) { \ + return details::FUNC(std::move(left), std::move(right)); \ + } \ + \ + template \ + requires(CON_VAL && CON_VALUE) \ + auto inline operator OP(LHS&& left, RHS&& right) { \ + auto&& rhsV = make_value(std::forward(right)); \ + return details::FUNC(std::move(left), std::move(rhsV)); \ + } \ + \ + template \ + requires(CON_VALUE && CON_VAL) \ + auto inline operator OP(LHS&& left, RHS&& right) { \ + auto&& lhsV = make_value(std::forward(left)); \ + return details::FUNC(std::move(lhsV), std::move(right)); \ } DEFINE_BINARY_OPERATOR(+, add, is_fundamental_val, convertible_to_fundamental) diff --git a/nautilus/include/nautilus/val_ptr.hpp b/nautilus/include/nautilus/val_ptr.hpp index 60179a40..5648a0a1 100644 --- a/nautilus/include/nautilus/val_ptr.hpp +++ b/nautilus/include/nautilus/val_ptr.hpp @@ -17,11 +17,11 @@ class val { const tracing::TypedValueRefHolder state; #endif #ifdef ENABLE_TRACING - val(ValueType ref) : state(tracing::value_ref()), ptr(&ref) { + val(ValueType ref) : state(tracing::TypedValueRef()), ptr(&ref) { } - val(ValueType ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) { + val(ValueType ref, tracing::TypedValueRef TypedValueRef) : state(TypedValueRef), ptr(&ref) { } - val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) { + val(val ptr, tracing::TypedValueRef ref) : state(ref), ptr(ptr) { } #else val(ValueType ref) : ptr(&ref) { @@ -38,7 +38,7 @@ class val { // store value #ifdef ENABLE_TRACING if (tracing::inTracer()) { - tracing::traceStore(state, value.state, tracing::to_type()); + tracing::traceBinaryOp(tracing::STORE, Type::v, state, value.state); return; } #endif @@ -52,7 +52,7 @@ class val { // store value #ifdef ENABLE_TRACING if (tracing::inTracer()) { - tracing::traceStore(ptr.state, other.state, tracing::to_type()); + tracing::traceBinaryOp(tracing::STORE, Type::v, ptr.state, other.state); return; } #endif @@ -64,7 +64,7 @@ class val { // load #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto ref = tracing::traceLoad(ptr.state, tracing::to_type()); + auto& ref = tracing::traceUnaryOp(tracing::LOAD, tracing::to_type(), ptr.state); return val(ref); } #endif @@ -90,12 +90,12 @@ class base_ptr_val { #ifdef ENABLE_TRACING base_ptr_val(ValuePtrType ptr) : state(tracing::traceConstant((void*) ptr)), value(ptr) { } - base_ptr_val(ValuePtrType ptr, tracing::value_ref tc) : state(tc), value(ptr) { + base_ptr_val(ValuePtrType ptr, tracing::TypedValueRef tc) : state(tc), value(ptr) { } base_ptr_val(ValuePtrType ptr, tracing::TypedValueRefHolder tc) : state(std::move(tc)), value(ptr) { } - base_ptr_val(tracing::value_ref ref) : state(ref), value(nullptr) { + base_ptr_val(tracing::TypedValueRef ref) : state(ref), value(nullptr) { } #else base_ptr_val(ValuePtrType ptr) : value(ptr) { @@ -115,7 +115,8 @@ class val : public base_ptr_val { using ValType = typename base_ptr_val::ValType; #ifdef ENABLE_TRACING - val(const val& otherValue) : base_ptr_val(otherValue.value, tracing::traceCopy(otherValue.state)) { + val(const val& otherValue) + : base_ptr_val(otherValue.value, tracing::traceCopy(otherValue.state)) { } #else val(const val& otherValue) : base_ptr_val(otherValue.value) { @@ -191,7 +192,8 @@ class val : public base_ptr_val { using base_ptr_val::base_ptr_val; #ifdef ENABLE_TRACING - val(const val& otherValue) : base_ptr_val(otherValue.value, tracing::traceCopy(otherValue.state)) { + val(const val& otherValue) + : base_ptr_val(otherValue.value, tracing::traceCopy(otherValue.state)) { } #else val(const val& otherValue) : base_ptr_val(otherValue.value) { @@ -356,11 +358,11 @@ class val { #ifdef ENABLE_TRACING tracing::TypedValueRefHolder state; - val(bool ref) : state(tracing::value_ref()), ptr(&ref) { + val(bool ref) : state(tracing::TypedValueRef()), ptr(&ref) { } - val(bool& ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) { + val(bool& ref, tracing::TypedValueRef TypedValueRef) : state(TypedValueRef), ptr(&ref) { } - val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) { + val(val ptr, tracing::TypedValueRef ref) : state(ref), ptr(ptr) { } #else val(bool ref) : ptr(&ref) { @@ -377,7 +379,7 @@ class val { // store value #ifdef ENABLE_TRACING if (tracing::inTracer()) { - tracing::traceStore(state, value.state, tracing::to_type()); + tracing::traceBinaryOp(tracing::STORE, Type::v, state, value.state); return; } #endif @@ -391,7 +393,7 @@ class val { // store value #ifdef ENABLE_TRACING if (tracing::inTracer()) { - tracing::traceStore(ptr.state, other.state, tracing::to_type()); + tracing::traceBinaryOp(tracing::STORE, Type::v, ptr.state, other.state); return; } #endif @@ -403,7 +405,7 @@ class val { // load #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto ref = tracing::traceLoad(ptr.state, tracing::to_type()); + auto& ref = tracing::traceUnaryOp(tracing::LOAD, tracing::to_type(), ptr.state); return val(ref); } #endif diff --git a/nautilus/src/nautilus/common/TypedValueRefHolder.cpp b/nautilus/src/nautilus/common/TypedValueRefHolder.cpp index e58176ee..12147e6b 100644 --- a/nautilus/src/nautilus/common/TypedValueRefHolder.cpp +++ b/nautilus/src/nautilus/common/TypedValueRefHolder.cpp @@ -22,7 +22,8 @@ TypedValueRefHolder::TypedValueRefHolder(nautilus::tracing::TypedValueRef valueR #endif } -TypedValueRefHolder::TypedValueRefHolder(const nautilus::tracing::TypedValueRefHolder& other) : valueRef(other.valueRef) { +TypedValueRefHolder::TypedValueRefHolder(const nautilus::tracing::TypedValueRefHolder& other) + : valueRef(other.valueRef) { #ifdef ENABLE_TRACING if (!inTracer()) return; @@ -30,7 +31,8 @@ TypedValueRefHolder::TypedValueRefHolder(const nautilus::tracing::TypedValueRefH #endif } -TypedValueRefHolder::TypedValueRefHolder(const nautilus::tracing::TypedValueRefHolder&& other) : valueRef(other.valueRef) { +TypedValueRefHolder::TypedValueRefHolder(const nautilus::tracing::TypedValueRefHolder&& other) + : valueRef(other.valueRef) { #ifdef ENABLE_TRACING if (!inTracer()) return; diff --git a/nautilus/src/nautilus/compiler/DumpHandler.cpp b/nautilus/src/nautilus/compiler/DumpHandler.cpp index 6b35ff05..cd20f531 100644 --- a/nautilus/src/nautilus/compiler/DumpHandler.cpp +++ b/nautilus/src/nautilus/compiler/DumpHandler.cpp @@ -13,10 +13,12 @@ std::filesystem::path getRootPath(const engine::Options&, const nautilus::compil return path; } -DumpHandler::DumpHandler(const engine::Options& options, const nautilus::compiler::CompilationUnitID& id) : options(options), id(id), rootPath(getRootPath(options, id)) { +DumpHandler::DumpHandler(const engine::Options& options, const nautilus::compiler::CompilationUnitID& id) + : options(options), id(id), rootPath(getRootPath(options, id)) { } -void DumpHandler::dump(std::string_view dumpName, std::string_view extension, const std::function& dumpFunction) const { +void DumpHandler::dump(std::string_view dumpName, std::string_view extension, + const std::function& dumpFunction) const { if (shouldDump(dumpName)) { auto content = dumpFunction(); if (dumpToConsole()) { @@ -32,7 +34,8 @@ void DumpHandler::dump(std::string_view dumpName, std::string_view extension, co } bool DumpHandler::shouldDump(std::string_view dumpName) const { - return options.getOptionOrDefault("dump.all", false) || options.getOptionOrDefault("dump." + std::string(dumpName), false); + return options.getOptionOrDefault("dump.all", false) || + options.getOptionOrDefault("dump." + std::string(dumpName), false); } bool DumpHandler::dumpToConsole() const { diff --git a/nautilus/src/nautilus/compiler/JITCompiler.cpp b/nautilus/src/nautilus/compiler/JITCompiler.cpp index 383224d2..b9a9138b 100644 --- a/nautilus/src/nautilus/compiler/JITCompiler.cpp +++ b/nautilus/src/nautilus/compiler/JITCompiler.cpp @@ -25,7 +25,8 @@ namespace nautilus::compiler { JITCompiler::JITCompiler() : options(), backends(std::make_unique()) { } -JITCompiler::JITCompiler(engine::Options options) : options(std::move(options)), backends(std::make_unique()) { +JITCompiler::JITCompiler(engine::Options options) + : options(std::move(options)), backends(std::make_unique()) { } JITCompiler::~JITCompiler() = default; diff --git a/nautilus/src/nautilus/compiler/backends/amsjit/A64LoweringProvider.cpp b/nautilus/src/nautilus/compiler/backends/amsjit/A64LoweringProvider.cpp index 7cd81fdb..4764bab4 100644 --- a/nautilus/src/nautilus/compiler/backends/amsjit/A64LoweringProvider.cpp +++ b/nautilus/src/nautilus/compiler/backends/amsjit/A64LoweringProvider.cpp @@ -16,7 +16,8 @@ namespace nautilus::compiler::asmjit { using namespace ::asmjit; -A64LoweringProvider::LoweringContext::LoweringContext(std::shared_ptr ir, CodeHolder& code) : cc(&code), ir(std::move(ir)) { +A64LoweringProvider::LoweringContext::LoweringContext(std::shared_ptr ir, CodeHolder& code) + : cc(&code), ir(std::move(ir)) { } void* A64LoweringProvider::lower(std::shared_ptr ir, ::asmjit::JitRuntime& runtime) { diff --git a/nautilus/src/nautilus/compiler/backends/bc/BCInterpreter.cpp b/nautilus/src/nautilus/compiler/backends/bc/BCInterpreter.cpp index d2acd36e..fa50ad8e 100644 --- a/nautilus/src/nautilus/compiler/backends/bc/BCInterpreter.cpp +++ b/nautilus/src/nautilus/compiler/backends/bc/BCInterpreter.cpp @@ -428,7 +428,8 @@ static Operation* OpTable[] = { }; -FunctionCallTarget::FunctionCallTarget(std::vector> arguments, void* functionPtr) : arguments(std::move(arguments)), functionPtr(functionPtr) { +FunctionCallTarget::FunctionCallTarget(std::vector> arguments, void* functionPtr) + : arguments(std::move(arguments)), functionPtr(functionPtr) { } BCInterpreter::BCInterpreter(Code code, RegisterFile registerFile) : code(std::move(code)), registerFile(registerFile) { diff --git a/nautilus/src/nautilus/compiler/backends/bc/BCInterpreterBackend.cpp b/nautilus/src/nautilus/compiler/backends/bc/BCInterpreterBackend.cpp index 89e46350..2c7a74f3 100644 --- a/nautilus/src/nautilus/compiler/backends/bc/BCInterpreterBackend.cpp +++ b/nautilus/src/nautilus/compiler/backends/bc/BCInterpreterBackend.cpp @@ -7,7 +7,8 @@ #include namespace nautilus::compiler::bc { -std::unique_ptr BCInterpreterBackend::compile(const std::shared_ptr& ir, const DumpHandler& dumpHandler, const engine::Options&) { +std::unique_ptr BCInterpreterBackend::compile(const std::shared_ptr& ir, + const DumpHandler& dumpHandler, const engine::Options&) { auto result = BCLoweringProvider().lower(ir); auto code = std::get<0>(result); dumpHandler.dump("after_bc_generation", "bc", [&]() { return code.toString(); }); diff --git a/nautilus/src/nautilus/compiler/backends/bc/BCLoweringProvider.cpp b/nautilus/src/nautilus/compiler/backends/bc/BCLoweringProvider.cpp index c04ebbd7..bdbf9724 100644 --- a/nautilus/src/nautilus/compiler/backends/bc/BCLoweringProvider.cpp +++ b/nautilus/src/nautilus/compiler/backends/bc/BCLoweringProvider.cpp @@ -724,7 +724,8 @@ void BCLoweringProvider::LoweringContext::process(ir::StoreOperation* storeOp, s program.blocks[block].code.emplace_back(oc); } -void BCLoweringProvider::LoweringContext::process(ir::BinaryCompOperation* binaryCompOperation, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::process(ir::BinaryCompOperation* binaryCompOperation, short block, + RegisterFrame& frame) { auto leftReg = frame.getValue(binaryCompOperation->getLeftInput()->getIdentifier()); auto rightReg = frame.getValue(binaryCompOperation->getRightInput()->getIdentifier()); auto resultReg = getResultRegister(binaryCompOperation, frame); @@ -846,7 +847,8 @@ void BCLoweringProvider::LoweringContext::process(ir::BinaryCompOperation* binar program.blocks[block].code.emplace_back(oc); } -void BCLoweringProvider::LoweringContext::process(ir::ShiftOperation* shiftOperation, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::process(ir::ShiftOperation* shiftOperation, short block, + RegisterFrame& frame) { auto leftReg = frame.getValue(shiftOperation->getLeftInput()->getIdentifier()); auto rightReg = frame.getValue(shiftOperation->getRightInput()->getIdentifier()); auto resultReg = getResultRegister(shiftOperation, frame); @@ -944,7 +946,8 @@ void BCLoweringProvider::LoweringContext::process(ir::ShiftOperation* shiftOpera program.blocks[block].code.emplace_back(oc); } -void BCLoweringProvider::LoweringContext::process(const ir::BasicBlockInvocation& bi, short block, RegisterFrame& parentFrame) { +void BCLoweringProvider::LoweringContext::process(const ir::BasicBlockInvocation& bi, short block, + RegisterFrame& parentFrame) { auto blockInputArguments = bi.getArguments(); auto& blockTargetArguments = bi.getBlock()->getArguments(); std::vector tempArgs; @@ -990,7 +993,8 @@ void BCLoweringProvider::LoweringContext::process(ir::BranchOperation* branchOp, program.blocks[block].terminatorOp = BranchOp {blockIndex}; } -void BCLoweringProvider::LoweringContext::process(const std::unique_ptr& opt, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::process(const std::unique_ptr& opt, short block, + RegisterFrame& frame) { switch (opt->getOperationType()) { case ir::Operation::OperationType::ConstPtrOp: { auto constPtr = as(opt); @@ -1161,7 +1165,8 @@ void BCLoweringProvider::LoweringContext::process(ir::ProxyCallOperation* opt, s processDynamicCall(opt, block, frame); } -void BCLoweringProvider::LoweringContext::processDynamicCall(ir::ProxyCallOperation* opt, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::processDynamicCall(ir::ProxyCallOperation* opt, short block, + RegisterFrame& frame) { auto& code = program.blocks[block].code; // NES_DEBUG("CREATE " << opt->toString() << " : " << // opt->getStamp()->toString()) @@ -1278,7 +1283,8 @@ void BCLoweringProvider::LoweringContext::processDynamicCall(ir::ProxyCallOperat } } -void BCLoweringProvider::LoweringContext::process(ir::NotOperation* negateOperation, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::process(ir::NotOperation* negateOperation, short block, + RegisterFrame& frame) { auto input = frame.getValue(negateOperation->getInput()->getIdentifier()); auto resultReg = getResultRegister(negateOperation, frame); frame.setValue(negateOperation->getIdentifier(), resultReg); @@ -1287,7 +1293,8 @@ void BCLoweringProvider::LoweringContext::process(ir::NotOperation* negateOperat program.blocks[block].code.emplace_back(oc); } -void BCLoweringProvider::LoweringContext::process(ir::NegateOperation* negateOperation, short block, RegisterFrame& frame) { +void BCLoweringProvider::LoweringContext::process(ir::NegateOperation* negateOperation, short block, + RegisterFrame& frame) { auto input = frame.getValue(negateOperation->getInput()->getIdentifier()); auto resultReg = getResultRegister(negateOperation, frame); frame.setValue(negateOperation->getIdentifier(), resultReg); diff --git a/nautilus/src/nautilus/compiler/backends/cpp/CPPCompilationBackend.cpp b/nautilus/src/nautilus/compiler/backends/cpp/CPPCompilationBackend.cpp index 39087c6c..1d2b8f2e 100644 --- a/nautilus/src/nautilus/compiler/backends/cpp/CPPCompilationBackend.cpp +++ b/nautilus/src/nautilus/compiler/backends/cpp/CPPCompilationBackend.cpp @@ -6,7 +6,8 @@ #include namespace nautilus::compiler::cpp { -std::unique_ptr CPPCompilationBackend::compile(const std::shared_ptr& ir, const DumpHandler& dumpHandler, const engine::Options&) { +std::unique_ptr CPPCompilationBackend::compile(const std::shared_ptr& ir, + const DumpHandler& dumpHandler, const engine::Options&) { auto code = CPPLoweringProvider::lower(ir); dumpHandler.dump("after_c_generation", ".c", [&]() { return code; }); diff --git a/nautilus/src/nautilus/compiler/backends/cpp/CPPCompiler.cpp b/nautilus/src/nautilus/compiler/backends/cpp/CPPCompiler.cpp index 97b2e2cf..76814840 100644 --- a/nautilus/src/nautilus/compiler/backends/cpp/CPPCompiler.cpp +++ b/nautilus/src/nautilus/compiler/backends/cpp/CPPCompiler.cpp @@ -88,7 +88,8 @@ SharedLibraryPtr CPPCompiler::compile(const std::string& identifier, const std:: return sharedLibrary; } -void CPPCompiler::compileSharedLib(CPPCompilerFlags flags, std::shared_ptr sourceFile, std::string) const { +void CPPCompiler::compileSharedLib(CPPCompilerFlags flags, std::shared_ptr sourceFile, + std::string) const { // lock file, such that no one can operate on the file at the same time const std::lock_guard fileLock(sourceFile->getFileMutex()); diff --git a/nautilus/src/nautilus/compiler/backends/cpp/CPPLoweringProvider.cpp b/nautilus/src/nautilus/compiler/backends/cpp/CPPLoweringProvider.cpp index 32adb0d5..04b07bb8 100644 --- a/nautilus/src/nautilus/compiler/backends/cpp/CPPLoweringProvider.cpp +++ b/nautilus/src/nautilus/compiler/backends/cpp/CPPLoweringProvider.cpp @@ -128,7 +128,8 @@ std::string CPPLoweringProvider::LoweringContext::process(const ir::BasicBlock* } } -void CPPLoweringProvider::LoweringContext::process(ir::CompareOperation* cmpOp, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(ir::CompareOperation* cmpOp, short blockIndex, + RegisterFrame& frame) { auto leftInput = frame.getValue(cmpOp->getLeftInput()->getIdentifier()); auto rightInput = frame.getValue(cmpOp->getRightInput()->getIdentifier()); auto resultVar = getVariable(cmpOp->getIdentifier()); @@ -138,7 +139,8 @@ void CPPLoweringProvider::LoweringContext::process(ir::CompareOperation* cmpOp, // we have to handle the special case that we want to do a null check. // Currently, Nautilus IR just contains a x == 0, thus we check if x is a ptr // type. - if (cmpOp->isEquals() && cmpOp->getLeftInput()->getStamp() == Type::ptr && isInteger(cmpOp->getRightInput()->getStamp())) { + if (cmpOp->isEquals() && cmpOp->getLeftInput()->getStamp() == Type::ptr && + isInteger(cmpOp->getRightInput()->getStamp())) { blocks[blockIndex] << resultVar << " = " << leftInput << " == nullptr;\n"; return; } @@ -172,21 +174,24 @@ void CPPLoweringProvider::LoweringContext::process(ir::LoadOperation* loadOp, sh blocks[blockIndex] << resultVar << " = *reinterpret_cast<" << type << "*>(" << address << ");\n"; } -void CPPLoweringProvider::LoweringContext::process(ir::StoreOperation* storeOp, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(ir::StoreOperation* storeOp, short blockIndex, + RegisterFrame& frame) { auto address = frame.getValue(storeOp->getAddress()->getIdentifier()); auto value = frame.getValue(storeOp->getValue()->getIdentifier()); auto type = getType(storeOp->getValue()->getStamp()); blocks[blockIndex] << "*reinterpret_cast<" << type << "*>(" << address << ") = " << value << ";\n"; } -void CPPLoweringProvider::LoweringContext::process(const ir::BasicBlockInvocation& bi, short blockIndex, RegisterFrame& parentFrame) { +void CPPLoweringProvider::LoweringContext::process(const ir::BasicBlockInvocation& bi, short blockIndex, + RegisterFrame& parentFrame) { auto blockInputArguments = bi.getArguments(); auto& blockTargetArguments = bi.getBlock()->getArguments(); blocks[blockIndex] << "// prepare block arguments\n"; blocks[blockIndex] << "{\n"; for (uint64_t i = 0; i < blockInputArguments.size(); i++) { auto blockArgument = blockInputArguments[i]->getIdentifier(); - blocks[blockIndex] << getType(blockTargetArguments[i]->getStamp()) << " temp_" << i << " = " << parentFrame.getValue(blockArgument) << ";\n"; + blocks[blockIndex] << getType(blockTargetArguments[i]->getStamp()) << " temp_" << i << " = " + << parentFrame.getValue(blockArgument) << ";\n"; } for (uint64_t i = 0; i < blockInputArguments.size(); i++) { auto blockTargetArgument = blockTargetArguments[i]->getIdentifier(); @@ -215,13 +220,15 @@ void CPPLoweringProvider::LoweringContext::process(ir::IfOperation* ifOpt, short blocks[blockIndex] << "goto " << falseBlock << ";}\n"; } -void CPPLoweringProvider::LoweringContext::process(ir::BranchOperation* branchOp, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(ir::BranchOperation* branchOp, short blockIndex, + RegisterFrame& frame) { process(branchOp->getNextBlockInvocation(), blockIndex, frame); auto nextBlock = process(branchOp->getNextBlockInvocation().getBlock(), frame); blocks[blockIndex] << "goto " << nextBlock << ";\n"; } -void CPPLoweringProvider::LoweringContext::process(const std::unique_ptr& opt, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(const std::unique_ptr& opt, short blockIndex, + RegisterFrame& frame) { switch (opt->getOperationType()) { case ir::Operation::OperationType::ConstBooleanOp: { processConst(opt, blockIndex, frame); @@ -356,7 +363,8 @@ void CPPLoweringProvider::LoweringContext::process(const std::unique_ptrgetStamp()); std::stringstream argTypes; @@ -385,7 +393,8 @@ void CPPLoweringProvider::LoweringContext::process(ir::ProxyCallOperation* opt, blocks[blockIndex] << "f_" << opt->getFunctionSymbol() << "(" << args.str() << ");\n"; } -void CPPLoweringProvider::LoweringContext::process(ir::NegateOperation* negateOperation, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(ir::NegateOperation* negateOperation, short blockIndex, + RegisterFrame& frame) { auto input = frame.getValue(negateOperation->getInput()->getIdentifier()); auto resultVar = getVariable(negateOperation->getIdentifier()); blockArguments << getType(negateOperation->getStamp()) << " " << resultVar << ";\n"; @@ -393,7 +402,8 @@ void CPPLoweringProvider::LoweringContext::process(ir::NegateOperation* negateOp blocks[blockIndex] << resultVar << "= ~" << input << ";\n"; } -void CPPLoweringProvider::LoweringContext::process(ir::NotOperation* notOperation, short blockIndex, RegisterFrame& frame) { +void CPPLoweringProvider::LoweringContext::process(ir::NotOperation* notOperation, short blockIndex, + RegisterFrame& frame) { auto input = frame.getValue(notOperation->getInput()->getIdentifier()); auto resultVar = getVariable(notOperation->getIdentifier()); blockArguments << getType(notOperation->getStamp()) << " " << resultVar << ";\n"; diff --git a/nautilus/src/nautilus/compiler/backends/cpp/SharedLibrary.cpp b/nautilus/src/nautilus/compiler/backends/cpp/SharedLibrary.cpp index 8876502c..6480ceba 100644 --- a/nautilus/src/nautilus/compiler/backends/cpp/SharedLibrary.cpp +++ b/nautilus/src/nautilus/compiler/backends/cpp/SharedLibrary.cpp @@ -8,7 +8,8 @@ namespace nautilus::compiler::cpp { -SharedLibrary::SharedLibrary(void* shareLib, std::string soAbsolutePath) : shareLib(shareLib), soAbsolutePath(std::move(soAbsolutePath)) { +SharedLibrary::SharedLibrary(void* shareLib, std::string soAbsolutePath) + : shareLib(shareLib), soAbsolutePath(std::move(soAbsolutePath)) { } SharedLibrary::~SharedLibrary() { diff --git a/nautilus/src/nautilus/compiler/backends/mlir/JITCompiler.cpp b/nautilus/src/nautilus/compiler/backends/mlir/JITCompiler.cpp index 3c9edbba..bf5e78ea 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/JITCompiler.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/JITCompiler.cpp @@ -8,8 +8,11 @@ namespace nautilus::compiler::mlir { -std::unique_ptr<::mlir::ExecutionEngine> JITCompiler::jitCompileModule(::mlir::OwningOpRef<::mlir::ModuleOp>& mlirModule, const llvm::function_ref optPipeline, - const std::vector& jitProxyFunctionSymbols, const std::vector& jitProxyFunctionTargetAddresses) { +std::unique_ptr<::mlir::ExecutionEngine> +JITCompiler::jitCompileModule(::mlir::OwningOpRef<::mlir::ModuleOp>& mlirModule, + const llvm::function_ref optPipeline, + const std::vector& jitProxyFunctionSymbols, + const std::vector& jitProxyFunctionTargetAddresses) { // Register the translation from MLIR to LLVM IR, which must happen before we // can JIT-compile. @@ -46,7 +49,8 @@ std::unique_ptr<::mlir::ExecutionEngine> JITCompiler::jitCompileModule(::mlir::O for (int i = 0; i < (int) jitProxyFunctionSymbols.size(); ++i) { auto address = jitProxyFunctionTargetAddresses.at(i); - symbolMap[interner(jitProxyFunctionSymbols.at(i))] = {llvm::orc::ExecutorAddr::fromPtr(address), llvm::JITSymbolFlags::Exported}; + symbolMap[interner(jitProxyFunctionSymbols.at(i))] = {llvm::orc::ExecutorAddr::fromPtr(address), + llvm::JITSymbolFlags::Exported}; } return symbolMap; }; diff --git a/nautilus/src/nautilus/compiler/backends/mlir/LLVMIROptimizer.cpp b/nautilus/src/nautilus/compiler/backends/mlir/LLVMIROptimizer.cpp index 735ea829..ba641f37 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/LLVMIROptimizer.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/LLVMIROptimizer.cpp @@ -15,7 +15,8 @@ int getOptimizationLevel(const engine::Options& options) { return options.getOptionOrDefault("mlir.optimizationLevel", 3); } -std::function LLVMIROptimizer::getLLVMOptimizerPipeline(const engine::Options& options, const DumpHandler& handler) { +std::function LLVMIROptimizer::getLLVMOptimizerPipeline(const engine::Options& options, + const DumpHandler& handler) { // Return LLVM optimizer pipeline. return [options, handler](llvm::Module* llvmIRModule) { // Currently, we do not increase the sizeLevel requirement of the @@ -30,9 +31,13 @@ std::function LLVMIROptimizer::getLLVMOptimizerPipel targetMachinePtr->setOptLevel(llvm::CodeGenOptLevel::Aggressive); // Add target-specific attributes to the 'execute' function. - llvmIRModule->getFunction("execute")->addAttributeAtIndex(~0, llvm::Attribute::get(llvmIRModule->getContext(), "target-cpu", targetMachinePtr->getTargetCPU())); - llvmIRModule->getFunction("execute")->addAttributeAtIndex(~0, llvm::Attribute::get(llvmIRModule->getContext(), "target-features", targetMachinePtr->getTargetFeatureString())); - llvmIRModule->getFunction("execute")->addAttributeAtIndex(~0, llvm::Attribute::get(llvmIRModule->getContext(), "tune-cpu", targetMachinePtr->getTargetCPU())); + llvmIRModule->getFunction("execute")->addAttributeAtIndex( + ~0, llvm::Attribute::get(llvmIRModule->getContext(), "target-cpu", targetMachinePtr->getTargetCPU())); + llvmIRModule->getFunction("execute")->addAttributeAtIndex( + ~0, llvm::Attribute::get(llvmIRModule->getContext(), "target-features", + targetMachinePtr->getTargetFeatureString())); + llvmIRModule->getFunction("execute")->addAttributeAtIndex( + ~0, llvm::Attribute::get(llvmIRModule->getContext(), "tune-cpu", targetMachinePtr->getTargetCPU())); llvm::SMDiagnostic Err; // Load LLVM IR module from proxy inlining input path (We assert that it @@ -46,7 +51,8 @@ std::function LLVMIROptimizer::getLLVMOptimizerPipel // llvm::Linker::Flags::OverrideFromSrc); // } - auto optPipeline = ::mlir::makeOptimizingTransformer(getOptimizationLevel(options), SIZE_LEVEL, targetMachinePtr); + auto optPipeline = + ::mlir::makeOptimizingTransformer(getOptimizationLevel(options), SIZE_LEVEL, targetMachinePtr); auto optimizedModule = optPipeline(llvmIRModule); handler.dump("after_llvm_generation", "ll", [&]() { diff --git a/nautilus/src/nautilus/compiler/backends/mlir/MLIRCompilationBackend.cpp b/nautilus/src/nautilus/compiler/backends/mlir/MLIRCompilationBackend.cpp index 0531eb8d..4683eb73 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/MLIRCompilationBackend.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/MLIRCompilationBackend.cpp @@ -16,7 +16,9 @@ namespace nautilus::compiler::mlir { -std::unique_ptr MLIRCompilationBackend::compile(const std::shared_ptr& ir, const DumpHandler& dumpHandler, const engine::Options& options) { +std::unique_ptr MLIRCompilationBackend::compile(const std::shared_ptr& ir, + const DumpHandler& dumpHandler, + const engine::Options& options) { // 1. Create the MLIRLoweringProvider and lower the given NESIR. Return an // MLIR module. @@ -54,7 +56,8 @@ std::unique_ptr MLIRCompilationBackend::compile(const std::shared_pt // 4. JIT compile LLVM IR module and return engine that provides access // compiled execute function. - auto engine = JITCompiler::jitCompileModule(mlirModule, optPipeline, loweringProvider->getJitProxyFunctionSymbols(), loweringProvider->getJitProxyTargetAddresses()); + auto engine = JITCompiler::jitCompileModule(mlirModule, optPipeline, loweringProvider->getJitProxyFunctionSymbols(), + loweringProvider->getJitProxyTargetAddresses()); if (options.getOptionOrDefault("mlir.eager_compilation", false)) { auto result = engine->lookupPacked("execute"); if (!result) { diff --git a/nautilus/src/nautilus/compiler/backends/mlir/MLIRLoweringProvider.cpp b/nautilus/src/nautilus/compiler/backends/mlir/MLIRLoweringProvider.cpp index b69c97c2..093a2118 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/MLIRLoweringProvider.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/MLIRLoweringProvider.cpp @@ -69,7 +69,8 @@ mlir::Value MLIRLoweringProvider::getConstInt(const std::string& location, Type } mlir::Value MLIRLoweringProvider::getConstBool(const std::string& location, bool value) { - return builder->create(getNameLoc(location), builder->getI1Type(), builder->getIntegerAttr(builder->getIndexType(), value)); + return builder->create(getNameLoc(location), builder->getI1Type(), + builder->getIntegerAttr(builder->getIndexType(), value)); } // Todo Issue #3004: Currently, we are simply adding 'Query_1' as the @@ -182,7 +183,9 @@ mlir::arith::CmpIPredicate convertToBooleanMLIRComparison(ir::CompareOperation:: } } -mlir::FlatSymbolRefAttr MLIRLoweringProvider::insertExternalFunction(const std::string& name, void* functionPtr, mlir::Type resultType, std::vector argTypes, bool varArgs) { +mlir::FlatSymbolRefAttr MLIRLoweringProvider::insertExternalFunction(const std::string& name, void* functionPtr, + mlir::Type resultType, + std::vector argTypes, bool varArgs) { // Create function arg & result types (currently only int for result). mlir::LLVM::LLVMFunctionType llvmFnType = mlir::LLVM::LLVMFunctionType::get(resultType, argTypes, varArgs); @@ -320,7 +323,8 @@ void MLIRLoweringProvider::generateMLIR(const std::unique_ptr& op void MLIRLoweringProvider::generateMLIR(ir::NegateOperation* negateOperation, ValueFrame& frame) { auto input = frame.getValue(negateOperation->getInput()->getIdentifier()); - auto constInt = builder->create(getNameLoc("location"), input.getType(), builder->getIntegerAttr(input.getType(), ~0)); + auto constInt = builder->create(getNameLoc("location"), input.getType(), + builder->getIntegerAttr(input.getType(), ~0)); auto negate = builder->create(getNameLoc("comparison"), input, constInt); frame.setValue(negateOperation->getIdentifier(), negate); } @@ -363,7 +367,6 @@ void MLIRLoweringProvider::generateMLIR(const ir::FunctionOperation& functionOp, inputTypes.emplace_back(getMLIRType(inputArg->getStamp())); } llvm::SmallVector outputTypes(1, getMLIRType(functionOp.getOutputArg())); - ; auto functionInOutTypes = builder->getFunctionType(inputTypes, outputTypes); auto loc = getNameLoc("EntryPoint"); auto mlirFunction = builder->create(loc, functionOp.getName(), functionInOutTypes); @@ -415,29 +418,36 @@ void MLIRLoweringProvider::generateMLIR(ir::LoadOperation* loadOp, ValueFrame& f // address"), // mlir::LLVM::LLVMPointerType::get(context), // address); - auto mlirLoadOp = builder->create(getNameLoc("loadedValue"), getMLIRType(loadOp->getStamp()), address); + auto mlirLoadOp = + builder->create(getNameLoc("loadedValue"), getMLIRType(loadOp->getStamp()), address); frame.setValue(loadOp->getIdentifier(), mlirLoadOp); } void MLIRLoweringProvider::generateMLIR(ir::ConstIntOperation* constIntOp, ValueFrame& frame) { if (!frame.contains(constIntOp->getIdentifier())) { - frame.setValue(constIntOp->getIdentifier(), getConstInt("ConstantOp", constIntOp->getStamp(), constIntOp->getValue())); + frame.setValue(constIntOp->getIdentifier(), + getConstInt("ConstantOp", constIntOp->getStamp(), constIntOp->getValue())); } else { - frame.setValue(constIntOp->getIdentifier(), getConstInt("ConstantOp", constIntOp->getStamp(), constIntOp->getValue())); + frame.setValue(constIntOp->getIdentifier(), + getConstInt("ConstantOp", constIntOp->getStamp(), constIntOp->getValue())); } } void MLIRLoweringProvider::generateMLIR(ir::ConstPtrOperation* constPtr, ValueFrame& frame) { int64_t val = (int64_t) constPtr->getValue(); - auto constInt = builder->create(getNameLoc("location"), builder->getI64Type(), builder->getIntegerAttr(builder->getI64Type(), val)); - auto elementAddress = builder->create(getNameLoc("fieldAccess"), mlir::LLVM::LLVMPointerType::get(context), constInt); + auto constInt = builder->create(getNameLoc("location"), builder->getI64Type(), + builder->getIntegerAttr(builder->getI64Type(), val)); + auto elementAddress = builder->create(getNameLoc("fieldAccess"), + mlir::LLVM::LLVMPointerType::get(context), constInt); frame.setValue(constPtr->getIdentifier(), elementAddress); } void MLIRLoweringProvider::generateMLIR(ir::ConstFloatOperation* constFloatOp, ValueFrame& frame) { if (isFloat(constFloatOp->getStamp())) { auto floatType = (constFloatOp->getStamp() == Type::f32) ? builder->getF32Type() : builder->getF64Type(); - frame.setValue(constFloatOp->getIdentifier(), builder->create(getNameLoc("constantFloat"), floatType, builder->getFloatAttr(floatType, constFloatOp->getValue()))); + frame.setValue(constFloatOp->getIdentifier(), builder->create( + getNameLoc("constantFloat"), floatType, + builder->getFloatAttr(floatType, constFloatOp->getValue()))); } } @@ -449,11 +459,14 @@ void MLIRLoweringProvider::generateMLIR(ir::AddOperation* addOp, ValueFrame& fra auto rightInput = frame.getValue(addOp->getRightInput()->getIdentifier()); if (addOp->getLeftInput()->getStamp() == Type::ptr) { // if we add something to a ptr we have to use a llvm getelementptr - mlir::Value elementAddress = builder->create(getNameLoc("fieldAccess"), mlir::LLVM::LLVMPointerType::get(context), builder->getI8Type(), leftInput, mlir::ArrayRef({rightInput})); + mlir::Value elementAddress = builder->create( + getNameLoc("fieldAccess"), mlir::LLVM::LLVMPointerType::get(context), builder->getI8Type(), leftInput, + mlir::ArrayRef({rightInput})); frame.setValue(addOp->getIdentifier(), elementAddress); } else if (isFloat(addOp->getStamp())) { - auto mlirAddOp = builder->create(getNameLoc("binOpResult"), leftInput.getType(), leftInput, rightInput, mlir::LLVM::FastmathFlags::fast); + auto mlirAddOp = builder->create(getNameLoc("binOpResult"), leftInput.getType(), leftInput, + rightInput, mlir::LLVM::FastmathFlags::fast); frame.setValue(addOp->getIdentifier(), mlirAddOp); } else { if (!inductionVars.contains(addOp->getLeftInput()->getIdentifier())) { @@ -473,11 +486,15 @@ void MLIRLoweringProvider::generateMLIR(ir::SubOperation* subIntOp, ValueFrame& auto rightInput = frame.getValue(subIntOp->getRightInput()->getIdentifier()); if (subIntOp->getLeftInput()->getStamp() == Type::ptr) { // if we add something to a ptr we have to use a llvm getelementptr - mlir::Value elementAddress = builder->create(getNameLoc("fieldAccess"), mlir::LLVM::LLVMPointerType::get(context), builder->getI8Type(), leftInput, mlir::ArrayRef({rightInput})); + mlir::Value elementAddress = builder->create( + getNameLoc("fieldAccess"), mlir::LLVM::LLVMPointerType::get(context), builder->getI8Type(), leftInput, + mlir::ArrayRef({rightInput})); frame.setValue(subIntOp->getIdentifier(), elementAddress); } else if (isFloat(subIntOp->getStamp())) { - auto mlirSubOp = builder->create(getNameLoc("binOpResult"), leftInput, rightInput, mlir::LLVM::FastmathFlagsAttr::get(context, mlir::LLVM::FastmathFlags::fast)); + auto mlirSubOp = builder->create( + getNameLoc("binOpResult"), leftInput, rightInput, + mlir::LLVM::FastmathFlagsAttr::get(context, mlir::LLVM::FastmathFlags::fast)); frame.setValue(subIntOp->getIdentifier(), mlirSubOp); } else { auto mlirSubOp = builder->create(getNameLoc("binOpResult"), leftInput, rightInput); @@ -490,10 +507,12 @@ void MLIRLoweringProvider::generateMLIR(ir::MulOperation* mulOp, ValueFrame& fra auto rightInput = frame.getValue(mulOp->getRightInput()->getIdentifier()); auto resultType = leftInput.getType(); if (isFloat(mulOp->getStamp())) { - auto mlirMulOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput, mlir::LLVM::FastmathFlags::fast); + auto mlirMulOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, + rightInput, mlir::LLVM::FastmathFlags::fast); frame.setValue(mulOp->getIdentifier(), mlirMulOp); } else { - auto mlirMulOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); + auto mlirMulOp = + builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); frame.setValue(mulOp->getIdentifier(), mlirMulOp); } } @@ -503,14 +522,17 @@ void MLIRLoweringProvider::generateMLIR(ir::DivOperation* divIntOp, ValueFrame& auto rightInput = frame.getValue(divIntOp->getRightInput()->getIdentifier()); auto resultType = leftInput.getType(); if (isFloat(divIntOp->getStamp())) { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput, mlir::LLVM::FastmathFlags::fast); + auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, + rightInput, mlir::LLVM::FastmathFlags::fast); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } else { if (resultType.isSignedInteger()) { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); + auto mlirDivOp = + builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } else { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); + auto mlirDivOp = + builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } } @@ -521,14 +543,17 @@ void MLIRLoweringProvider::generateMLIR(ir::ModOperation* divIntOp, ValueFrame& auto rightInput = frame.getValue(divIntOp->getRightInput()->getIdentifier()); auto resultType = leftInput.getType(); if (isFloat(divIntOp->getStamp())) { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput, mlir::LLVM::FastmathFlags::fast); + auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, + rightInput, mlir::LLVM::FastmathFlags::fast); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } else { if (resultType.isSignedInteger()) { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); + auto mlirDivOp = + builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } else { - auto mlirDivOp = builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); + auto mlirDivOp = + builder->create(getNameLoc("binOpResult"), resultType, leftInput, rightInput); frame.setValue(divIntOp->getIdentifier(), mlirDivOp); } } @@ -545,7 +570,8 @@ void MLIRLoweringProvider::generateMLIR(ir::ReturnOperation* returnOp, ValueFram if (!returnOp->hasReturnValue()) { builder->create(getNameLoc("return"), mlir::ValueRange()); } else { - builder->create(getNameLoc("return"), frame.getValue(returnOp->getReturnValue()->getIdentifier())); + builder->create(getNameLoc("return"), + frame.getValue(returnOp->getReturnValue()->getIdentifier())); } } @@ -554,7 +580,9 @@ void MLIRLoweringProvider::generateMLIR(ir::ProxyCallOperation* proxyCallOp, Val if (theModule.lookupSymbol(proxyCallOp->getFunctionSymbol())) { functionRef = mlir::SymbolRefAttr::get(context, proxyCallOp->getFunctionSymbol()); } else { - functionRef = insertExternalFunction(proxyCallOp->getFunctionSymbol(), proxyCallOp->getFunctionPtr(), getMLIRType(proxyCallOp->getStamp()), getMLIRType(proxyCallOp->getInputArguments()), true); + functionRef = insertExternalFunction(proxyCallOp->getFunctionSymbol(), proxyCallOp->getFunctionPtr(), + getMLIRType(proxyCallOp->getStamp()), + getMLIRType(proxyCallOp->getInputArguments()), true); } std::vector functionArgs; @@ -562,7 +590,8 @@ void MLIRLoweringProvider::generateMLIR(ir::ProxyCallOperation* proxyCallOp, Val functionArgs.push_back(frame.getValue(arg->getIdentifier())); } if (proxyCallOp->getStamp() != Type::v) { - auto res = builder->create(getNameLoc("printFunc"), getMLIRType(proxyCallOp->getStamp()), functionRef, functionArgs); + auto res = builder->create(getNameLoc("printFunc"), getMLIRType(proxyCallOp->getStamp()), + functionRef, functionArgs); frame.setValue(proxyCallOp->getIdentifier(), res.getResult()); } else { builder->create(builder->getUnknownLoc(), mlir::TypeRange(), functionRef, functionArgs); @@ -576,7 +605,9 @@ void MLIRLoweringProvider::generateMLIR(ir::CompareOperation* compareOp, ValueFr if ((isInteger(leftStamp) && isFloat(rightStamp)) || ((isInteger(rightStamp) && isFloat(leftStamp)))) { // Avoid comparing integer to float throw NotImplementedException("Type missmatch: cannot compare"); - } else if (compareOp->getComparator() == ir::CompareOperation::EQ && compareOp->getLeftInput()->getStamp() == Type::ptr && isInteger(compareOp->getRightInput()->getStamp())) { + } else if (compareOp->getComparator() == ir::CompareOperation::EQ && + compareOp->getLeftInput()->getStamp() == Type::ptr && + isInteger(compareOp->getRightInput()->getStamp())) { // add null check throw NotImplementedException("Null check is not implemented"); // auto null = @@ -590,22 +621,30 @@ void MLIRLoweringProvider::generateMLIR(ir::CompareOperation* compareOp, ValueFr // frame.setValue(compareOp->getIdentifier(), cmpOp); } else if (isInteger(leftStamp) && isInteger(rightStamp)) { // handle integer - auto cmpOp = builder->create(getNameLoc("comparison"), convertToIntMLIRComparison(compareOp->getComparator(), leftStamp), frame.getValue(compareOp->getLeftInput()->getIdentifier()), - frame.getValue(compareOp->getRightInput()->getIdentifier())); + auto cmpOp = builder->create( + getNameLoc("comparison"), convertToIntMLIRComparison(compareOp->getComparator(), leftStamp), + frame.getValue(compareOp->getLeftInput()->getIdentifier()), + frame.getValue(compareOp->getRightInput()->getIdentifier())); frame.setValue(compareOp->getIdentifier(), cmpOp); } else if (isFloat(leftStamp) && isFloat(rightStamp)) { // handle float comparison - auto cmpOp = builder->create(getNameLoc("comparison"), convertToFloatMLIRComparison(compareOp->getComparator()), frame.getValue(compareOp->getLeftInput()->getIdentifier()), + auto cmpOp = builder->create(getNameLoc("comparison"), + convertToFloatMLIRComparison(compareOp->getComparator()), + frame.getValue(compareOp->getLeftInput()->getIdentifier()), frame.getValue(compareOp->getRightInput()->getIdentifier())); frame.setValue(compareOp->getIdentifier(), cmpOp); } else if (leftStamp == Type::b && rightStamp == Type::b) { // handle float comparison - auto cmpOp = builder->create(getNameLoc("comparison"), convertToBooleanMLIRComparison(compareOp->getComparator()), frame.getValue(compareOp->getLeftInput()->getIdentifier()), + auto cmpOp = builder->create(getNameLoc("comparison"), + convertToBooleanMLIRComparison(compareOp->getComparator()), + frame.getValue(compareOp->getLeftInput()->getIdentifier()), frame.getValue(compareOp->getRightInput()->getIdentifier())); frame.setValue(compareOp->getIdentifier(), cmpOp); } else if (leftStamp == Type::ptr && rightStamp == Type::ptr) { // handle float comparison - auto cmpOp = builder->create(getNameLoc("comparison"), convertToLLVMComparison(compareOp->getComparator()), frame.getValue(compareOp->getLeftInput()->getIdentifier()), + auto cmpOp = builder->create(getNameLoc("comparison"), + convertToLLVMComparison(compareOp->getComparator()), + frame.getValue(compareOp->getLeftInput()->getIdentifier()), frame.getValue(compareOp->getRightInput()->getIdentifier())); frame.setValue(compareOp->getIdentifier(), cmpOp); } else { @@ -629,7 +668,8 @@ void MLIRLoweringProvider::generateMLIR(ir::IfOperation* ifOp, ValueFrame& frame } builder->restoreInsertionPoint(parentBlockInsertionPoint); - builder->create(getNameLoc("branch"), frame.getValue(ifOp->getValue()->getIdentifier()), trueBlock, trueBlockArgs, elseBlock, elseBlockArgs); + builder->create(getNameLoc("branch"), frame.getValue(ifOp->getValue()->getIdentifier()), + trueBlock, trueBlockArgs, elseBlock, elseBlockArgs); } void MLIRLoweringProvider::generateMLIR(ir::BranchOperation* branchOp, ValueFrame& frame) { @@ -670,7 +710,9 @@ mlir::Block* MLIRLoweringProvider::generateBasicBlock(ir::BasicBlockInvocation& return mlirBasicBlock; } -MLIRLoweringProvider::ValueFrame MLIRLoweringProvider::createFrameFromParentBlock(MLIRLoweringProvider::ValueFrame& frame, ir::BasicBlockInvocation& invocation) { +MLIRLoweringProvider::ValueFrame +MLIRLoweringProvider::createFrameFromParentBlock(MLIRLoweringProvider::ValueFrame& frame, + ir::BasicBlockInvocation& invocation) { auto invocationArguments = invocation.getArguments(); auto& childBlockArguments = invocation.getBlock()->getArguments(); // NES_ASSERT(invocationArguments.size() == childBlockArguments.size(), @@ -747,17 +789,20 @@ void MLIRLoweringProvider::generateMLIR(ir::CastOperation* castOperation, MLIRLo } else if (getBitWith(inputStamp) < getBitWith(outputStamp)) { // upcast if (isSignedInteger(inputStamp) && (isUnsignedInteger(outputStamp) || isSignedInteger(outputStamp))) { - auto mlirCast = builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); + auto mlirCast = + builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); frame.setValue(castOperation->getIdentifier(), mlirCast); return; } else if (isUnsignedInteger(inputStamp) && (isUnsignedInteger(outputStamp) || isSignedInteger(outputStamp))) { - auto mlirCast = builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); + auto mlirCast = + builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); frame.setValue(castOperation->getIdentifier(), mlirCast); return; } } else if (isInteger(inputStamp) && isInteger(outputStamp) && getBitWith(inputStamp) > getBitWith(outputStamp)) { // downcast - auto mlirCast = builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); + auto mlirCast = + builder->create(getNameLoc("location"), getMLIRType(outputStamp), mlirInput); frame.setValue(castOperation->getIdentifier(), mlirCast); return; } @@ -765,7 +810,8 @@ void MLIRLoweringProvider::generateMLIR(ir::CastOperation* castOperation, MLIRLo throw NotImplementedException("Cast is not supported."); } -void MLIRLoweringProvider::generateMLIR(ir::BinaryCompOperation* binaryCompOperation, nautilus::compiler::mlir::MLIRLoweringProvider::ValueFrame& frame) { +void MLIRLoweringProvider::generateMLIR(ir::BinaryCompOperation* binaryCompOperation, + nautilus::compiler::mlir::MLIRLoweringProvider::ValueFrame& frame) { auto leftInput = frame.getValue(binaryCompOperation->getLeftInput()->getIdentifier()); auto rightInput = frame.getValue(binaryCompOperation->getRightInput()->getIdentifier()); @@ -784,7 +830,8 @@ void MLIRLoweringProvider::generateMLIR(ir::BinaryCompOperation* binaryCompOpera frame.setValue(binaryCompOperation->getIdentifier(), op); } -void MLIRLoweringProvider::generateMLIR(ir::ShiftOperation* shiftOperation, nautilus::compiler::mlir::MLIRLoweringProvider::ValueFrame& frame) { +void MLIRLoweringProvider::generateMLIR(ir::ShiftOperation* shiftOperation, + nautilus::compiler::mlir::MLIRLoweringProvider::ValueFrame& frame) { auto leftInput = frame.getValue(shiftOperation->getLeftInput()->getIdentifier()); auto rightInput = frame.getValue(shiftOperation->getRightInput()->getIdentifier()); @@ -800,8 +847,11 @@ void MLIRLoweringProvider::generateMLIR(ir::ShiftOperation* shiftOperation, naut frame.setValue(shiftOperation->getIdentifier(), op); } -void MLIRLoweringProvider::generateMLIR(ir::ConstBooleanOperation* constBooleanOp, MLIRLoweringProvider::ValueFrame& frame) { - auto constOp = builder->create(getNameLoc("location"), builder->getI1Type(), builder->getIntegerAttr(builder->getI1Type(), constBooleanOp->getValue())); +void MLIRLoweringProvider::generateMLIR(ir::ConstBooleanOperation* constBooleanOp, + MLIRLoweringProvider::ValueFrame& frame) { + auto constOp = builder->create( + getNameLoc("location"), builder->getI1Type(), + builder->getIntegerAttr(builder->getI1Type(), constBooleanOp->getValue())); frame.setValue(constBooleanOp->getIdentifier(), constOp); } diff --git a/nautilus/src/nautilus/compiler/backends/mlir/MLIRPassManager.cpp b/nautilus/src/nautilus/compiler/backends/mlir/MLIRPassManager.cpp index 01cbfc55..085c712d 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/MLIRPassManager.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/MLIRPassManager.cpp @@ -28,7 +28,8 @@ std::unique_ptr getMLIROptimizationPass(MLIRPassManager::Optimizatio throw NotImplementedException("pass is not supported"); } -int MLIRPassManager::lowerAndOptimizeMLIRModule(mlir::OwningOpRef& module, const std::vector& optimizationPasses) { +int MLIRPassManager::lowerAndOptimizeMLIRModule(mlir::OwningOpRef& module, + const std::vector& optimizationPasses) { mlir::PassManager passManager(module->getContext()); // Apply optimization passes. diff --git a/nautilus/src/nautilus/compiler/backends/mlir/MLIRUtility.cpp b/nautilus/src/nautilus/compiler/backends/mlir/MLIRUtility.cpp index 9c71a228..f5733f48 100644 --- a/nautilus/src/nautilus/compiler/backends/mlir/MLIRUtility.cpp +++ b/nautilus/src/nautilus/compiler/backends/mlir/MLIRUtility.cpp @@ -48,7 +48,8 @@ int MLIRUtility::loadAndExecuteModuleFromString(const std::string& mlirString, c return 0; } -std::unique_ptr MLIRUtility::compileNESIRToMachineCode(std::shared_ptr ir) { +std::unique_ptr +MLIRUtility::compileNESIRToMachineCode(std::shared_ptr ir) { mlir::MLIRContext context; auto loweringProvider = std::make_unique(context); auto module = loweringProvider->generateModuleFromIR(ir); @@ -63,6 +64,7 @@ std::unique_ptr MLIRUtility::compileNESIRToMachineCode(st // JIT compile LLVM IR module and return engine that provides access compiled // execute function. - return MLIR::JITCompiler::jitCompileModule(module, optPipeline, loweringProvider->getJitProxyFunctionSymbols(), loweringProvider->getJitProxyTargetAddresses()); + return MLIR::JITCompiler::jitCompileModule(module, optPipeline, loweringProvider->getJitProxyFunctionSymbols(), + loweringProvider->getJitProxyTargetAddresses()); } } // namespace nautilus::compiler::mlir diff --git a/nautilus/src/nautilus/compiler/ir/IRGraph.cpp b/nautilus/src/nautilus/compiler/ir/IRGraph.cpp index 1cddc131..99b4b0b8 100644 --- a/nautilus/src/nautilus/compiler/ir/IRGraph.cpp +++ b/nautilus/src/nautilus/compiler/ir/IRGraph.cpp @@ -119,7 +119,8 @@ struct formatter : formatter template <> struct formatter : formatter { - static auto format(const nautilus::compiler::ir::OperationIdentifier& op, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::compiler::ir::OperationIdentifier& op, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "${}", op.getId()); return out; @@ -128,7 +129,8 @@ struct formatter : formatter struct formatter : formatter { - static auto format(const nautilus::compiler::ir::BasicBlockInvocation& op, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::compiler::ir::BasicBlockInvocation& op, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "Block_{}(", op.getBlock()->getIdentifier()); const auto& args = op.getArguments(); @@ -147,14 +149,16 @@ template <> struct formatter : formatter { static auto format(const nautilus::compiler::ir::IfOperation& op, format_context& ctx) -> format_context::iterator { auto out = ctx.out(); - fmt::format_to(out, "if {} ? {} : {}", op.getValue()->getIdentifier(), op.getTrueBlockInvocation(), op.getFalseBlockInvocation()); + fmt::format_to(out, "if {} ? {} : {}", op.getValue()->getIdentifier(), op.getTrueBlockInvocation(), + op.getFalseBlockInvocation()); return out; } }; template <> struct formatter : formatter { - static auto format(const nautilus::compiler::ir::ProxyCallOperation& op, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::compiler::ir::ProxyCallOperation& op, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); if (op.getStamp() != nautilus::Type::v) { @@ -178,13 +182,17 @@ struct formatter : formatter format_context::iterator { auto out = ctx.out(); if (auto shiftOp = op.dynCast()) { - fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), shiftOp->getLeftInput()->getIdentifier(), shiftOpToString(shiftOp->getType()), shiftOp->getRightInput()->getIdentifier()); + fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), shiftOp->getLeftInput()->getIdentifier(), + shiftOpToString(shiftOp->getType()), shiftOp->getRightInput()->getIdentifier()); } else if (auto compOp = op.dynCast()) { - fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), compOp->getLeftInput()->getIdentifier(), compOpToString(compOp->getComparator()), compOp->getRightInput()->getIdentifier()); + fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), compOp->getLeftInput()->getIdentifier(), + compOpToString(compOp->getComparator()), compOp->getRightInput()->getIdentifier()); } else if (auto bcompOp = op.dynCast()) { - fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), bcompOp->getLeftInput()->getIdentifier(), shiftOpToString(bcompOp->getType()), bcompOp->getRightInput()->getIdentifier()); + fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), bcompOp->getLeftInput()->getIdentifier(), + shiftOpToString(bcompOp->getType()), bcompOp->getRightInput()->getIdentifier()); } else if (auto res = op.dynCast()) { - fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), res->getLeftInput()->getIdentifier(), binaryOpToString(op.getOperationType()), res->getRightInput()->getIdentifier()); + fmt::format_to(out, "{} = {} {} {}", op.getIdentifier(), res->getLeftInput()->getIdentifier(), + binaryOpToString(op.getOperationType()), res->getRightInput()->getIdentifier()); } else if (auto ifOp = op.dynCast()) { fmt::format_to(out, "{}", *ifOp); } else if (auto brOp = op.dynCast()) { @@ -205,11 +213,13 @@ struct formatter : formatter()) { fmt::format_to(out, "{}", *callOp); } else if (auto castOp = op.dynCast()) { - fmt::format_to(out, "{} = {} cast_to {}", castOp->getIdentifier(), castOp->getInput()->getIdentifier(), toString(castOp->getStamp())); + fmt::format_to(out, "{} = {} cast_to {}", castOp->getIdentifier(), castOp->getInput()->getIdentifier(), + toString(castOp->getStamp())); } else if (auto loadOp = op.dynCast()) { fmt::format_to(out, "{} = load({})", loadOp->getIdentifier(), loadOp->getAddress()->getIdentifier()); } else if (auto storeOp = op.dynCast()) { - fmt::format_to(out, "store({}, {})", storeOp->getValue()->getIdentifier(), storeOp->getAddress()->getIdentifier()); + fmt::format_to(out, "store({}, {})", storeOp->getValue()->getIdentifier(), + storeOp->getAddress()->getIdentifier()); } else if (auto notOp = op.dynCast()) { fmt::format_to(out, "{} = !{}", notOp->getIdentifier(), notOp->getInput()->getIdentifier()); } else if (auto negateOp = op.dynCast()) { @@ -224,14 +234,16 @@ struct formatter : formatter struct formatter : formatter { - static auto format(const nautilus::compiler::ir::BasicBlock& block, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::compiler::ir::BasicBlock& block, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "\nBlock_{}(", block.getIdentifier()); const auto& args = block.getArguments(); if (!args.empty()) { fmt::format_to(out, "{}:{}", args.at(0)->getIdentifier().toString(), toString(args.at(0)->getStamp())); for (size_t i = 1; i < args.size(); ++i) { - fmt::format_to(out, ", {}:{}", args.at(i)->getIdentifier().toString(), toString(args.at(i)->getStamp())); + fmt::format_to(out, ", {}:{}", args.at(i)->getIdentifier().toString(), + toString(args.at(i)->getStamp())); } } fmt::format_to(out, "):\n"); @@ -244,7 +256,8 @@ struct formatter : formatter struct formatter : formatter { - static auto format(const nautilus::compiler::ir::FunctionOperation& func, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::compiler::ir::FunctionOperation& func, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "{}(", func.getName()); for (const auto& arg : func.getInputArgNames()) { @@ -260,7 +273,8 @@ struct formatter : formatter::format(const nautilus::compiler::ir::IRGraph& graph, format_context& ctx) -> format_context::iterator { +auto fmt::formatter::format(const nautilus::compiler::ir::IRGraph& graph, + format_context& ctx) -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "NautilusIr {{\n"); auto& rootOp = graph.getRootOperation(); diff --git a/nautilus/src/nautilus/compiler/ir/blocks/BasicBlock.cpp b/nautilus/src/nautilus/compiler/ir/blocks/BasicBlock.cpp index 5245a32c..97525e33 100644 --- a/nautilus/src/nautilus/compiler/ir/blocks/BasicBlock.cpp +++ b/nautilus/src/nautilus/compiler/ir/blocks/BasicBlock.cpp @@ -7,7 +7,8 @@ #include namespace nautilus::compiler::ir { -BasicBlock::BasicBlock(uint16_t identifier, std::vector>& arguments) : identifier(identifier), operations(), arguments(std::move(arguments)) { +BasicBlock::BasicBlock(uint16_t identifier, std::vector>& arguments) + : identifier(identifier), operations(), arguments(std::move(arguments)) { } void BasicBlock::addNextBlock(BasicBlock* nextBlock, const std::vector& ops) { diff --git a/nautilus/src/nautilus/compiler/ir/blocks/BasicBlockArgument.cpp b/nautilus/src/nautilus/compiler/ir/blocks/BasicBlockArgument.cpp index b2711b0f..b3bdece6 100644 --- a/nautilus/src/nautilus/compiler/ir/blocks/BasicBlockArgument.cpp +++ b/nautilus/src/nautilus/compiler/ir/blocks/BasicBlockArgument.cpp @@ -2,6 +2,7 @@ #include "nautilus/compiler/ir/blocks/BasicBlockArgument.hpp" namespace nautilus::compiler::ir { -BasicBlockArgument::BasicBlockArgument(const OperationIdentifier identifier, Type stamp) : Operation(OperationType::BasicBlockArgument, identifier, stamp) { +BasicBlockArgument::BasicBlockArgument(const OperationIdentifier identifier, Type stamp) + : Operation(OperationType::BasicBlockArgument, identifier, stamp) { } } // namespace nautilus::compiler::ir diff --git a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/AddOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/AddOperation.cpp index 273eab52..92b0a1e2 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/AddOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/AddOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -AddOperation::AddOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::AddOp, identifier, leftInput->getStamp(), leftInput, rightInput) { +AddOperation::AddOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::AddOp, identifier, leftInput->getStamp(), leftInput, rightInput) { } bool AddOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/DivOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/DivOperation.cpp index 93bcf0b8..72dc8008 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/DivOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/DivOperation.cpp @@ -3,7 +3,8 @@ #include namespace nautilus::compiler::ir { -DivOperation::DivOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::DivOp, identifier, leftInput->getStamp(), leftInput, rightInput) { +DivOperation::DivOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::DivOp, identifier, leftInput->getStamp(), leftInput, rightInput) { } bool DivOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/ModOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/ModOperation.cpp index f12a2b09..93270ea3 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/ModOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/ModOperation.cpp @@ -4,7 +4,8 @@ #include namespace nautilus::compiler::ir { -ModOperation::ModOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::ModOp, identifier, leftInput->getStamp(), leftInput, rightInput) { +ModOperation::ModOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::ModOp, identifier, leftInput->getStamp(), leftInput, rightInput) { } bool ModOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/MulOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/MulOperation.cpp index 6b85f26e..99f5b8ee 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/MulOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/MulOperation.cpp @@ -4,7 +4,8 @@ #include namespace nautilus::compiler::ir { -MulOperation::MulOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::MulOp, identifier, leftInput->getStamp(), leftInput, rightInput) { +MulOperation::MulOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::MulOp, identifier, leftInput->getStamp(), leftInput, rightInput) { } bool MulOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/SubOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/SubOperation.cpp index 30f166d8..42424086 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/SubOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ArithmeticOperations/SubOperation.cpp @@ -3,7 +3,8 @@ #include namespace nautilus::compiler::ir { -SubOperation::SubOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::SubOp, identifier, leftInput->getStamp(), leftInput, rightInput) { +SubOperation::SubOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::SubOp, identifier, leftInput->getStamp(), leftInput, rightInput) { } bool SubOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/BinaryCompOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/BinaryCompOperation.cpp index a4d3329a..c2291670 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/BinaryCompOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/BinaryCompOperation.cpp @@ -4,7 +4,8 @@ namespace nautilus::compiler::ir { -BinaryCompOperation::BinaryCompOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, Type type) +BinaryCompOperation::BinaryCompOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, + Type type) : BinaryOperation(OperationType::BinaryComp, identifier, leftInput->getStamp(), leftInput, rightInput), type(type) { } diff --git a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/NegateOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/NegateOperation.cpp index a9f5f8e3..e803f8da 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/NegateOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/NegateOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -NegateOperation::NegateOperation(OperationIdentifier identifier, Operation* input) : Operation(OperationType::NegateOp, identifier, input->getStamp(), {input}) { +NegateOperation::NegateOperation(OperationIdentifier identifier, Operation* input) + : Operation(OperationType::NegateOp, identifier, input->getStamp(), {input}) { } bool NegateOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/ShiftOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/ShiftOperation.cpp index 1ded5d46..07ff0ebe 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/ShiftOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/BinaryOperations/ShiftOperation.cpp @@ -4,7 +4,9 @@ namespace nautilus::compiler::ir { -ShiftOperation::ShiftOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, ShiftType type) : BinaryOperation(OperationType::ShiftOp, identifier, leftInput->getStamp(), leftInput, rightInput), type(type) { +ShiftOperation::ShiftOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, + ShiftType type) + : BinaryOperation(OperationType::ShiftOp, identifier, leftInput->getStamp(), leftInput, rightInput), type(type) { } ShiftOperation::ShiftType ShiftOperation::getType() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/CastOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/CastOperation.cpp index 22538b46..ed7792b7 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/CastOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/CastOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -CastOperation::CastOperation(OperationIdentifier identifier, Operation* input, Type targetStamp) : Operation(OperationType::CastOp, identifier, targetStamp, {input}) { +CastOperation::CastOperation(OperationIdentifier identifier, Operation* input, Type targetStamp) + : Operation(OperationType::CastOp, identifier, targetStamp, {input}) { } Operation* CastOperation::getInput() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ConstBooleanOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ConstBooleanOperation.cpp index 70986285..ab2f04c0 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ConstBooleanOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ConstBooleanOperation.cpp @@ -5,7 +5,8 @@ namespace nautilus::compiler::ir { -ConstBooleanOperation::ConstBooleanOperation(OperationIdentifier identifier, bool constantValue) : Operation(OperationType::ConstBooleanOp, identifier, Type::b), constantValue(constantValue) { +ConstBooleanOperation::ConstBooleanOperation(OperationIdentifier identifier, bool constantValue) + : Operation(OperationType::ConstBooleanOp, identifier, Type::b), constantValue(constantValue) { } bool ConstBooleanOperation::getValue() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ConstFloatOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ConstFloatOperation.cpp index f6244584..402a10af 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ConstFloatOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ConstFloatOperation.cpp @@ -5,7 +5,8 @@ namespace nautilus::compiler::ir { -ConstFloatOperation::ConstFloatOperation(OperationIdentifier identifier, double constantValue, Type stamp) : Operation(OperationType::ConstFloatOp, identifier, stamp), constantValue(constantValue) { +ConstFloatOperation::ConstFloatOperation(OperationIdentifier identifier, double constantValue, Type stamp) + : Operation(OperationType::ConstFloatOp, identifier, stamp), constantValue(constantValue) { } double ConstFloatOperation::getValue() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ConstIntOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ConstIntOperation.cpp index b1f2285b..6d657ecb 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ConstIntOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ConstIntOperation.cpp @@ -6,7 +6,8 @@ namespace nautilus::compiler::ir { -ConstIntOperation::ConstIntOperation(OperationIdentifier identifier, int64_t constantValue, Type stamp) : Operation(OperationType::ConstIntOp, identifier, stamp), constantValue(constantValue) { +ConstIntOperation::ConstIntOperation(OperationIdentifier identifier, int64_t constantValue, Type stamp) + : Operation(OperationType::ConstIntOp, identifier, stamp), constantValue(constantValue) { } int64_t ConstIntOperation::getValue() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ConstPtrOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ConstPtrOperation.cpp index f8685e48..2730f2e3 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ConstPtrOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ConstPtrOperation.cpp @@ -6,7 +6,8 @@ namespace nautilus::compiler::ir { -ConstPtrOperation::ConstPtrOperation(OperationIdentifier identifier, void* constantValue) : Operation(OperationType::ConstPtrOp, identifier, Type::ptr), constantValue(constantValue) { +ConstPtrOperation::ConstPtrOperation(OperationIdentifier identifier, void* constantValue) + : Operation(OperationType::ConstPtrOp, identifier, Type::ptr), constantValue(constantValue) { } void* ConstPtrOperation::getValue() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/FunctionOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/FunctionOperation.cpp index dd4d82a2..21ce8a28 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/FunctionOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/FunctionOperation.cpp @@ -4,8 +4,12 @@ namespace nautilus::compiler::ir { -FunctionOperation::FunctionOperation(std::string name, std::vector>& functionBasicBlocks, std::vector inputArgs, std::vector inputArgNames, Type outputArg) - : Operation(OperationType::FunctionOp, outputArg), name(std::move(name)), functionBasicBlocks(std::move(functionBasicBlocks)), inputArgs(std::move(inputArgs)), inputArgNames(std::move(inputArgNames)) { +FunctionOperation::FunctionOperation(std::string name, std::vector>& functionBasicBlocks, + std::vector inputArgs, std::vector inputArgNames, + Type outputArg) + : Operation(OperationType::FunctionOp, outputArg), name(std::move(name)), + functionBasicBlocks(std::move(functionBasicBlocks)), inputArgs(std::move(inputArgs)), + inputArgNames(std::move(inputArgNames)) { } const std::string& FunctionOperation::getName() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/LoadOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/LoadOperation.cpp index 065739a5..d366d8aa 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/LoadOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/LoadOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -LoadOperation::LoadOperation(const OperationIdentifier& identifier, Operation* address, Type type) : Operation(OperationType::LoadOp, identifier, type, {address}) { +LoadOperation::LoadOperation(const OperationIdentifier& identifier, Operation* address, Type type) + : Operation(OperationType::LoadOp, identifier, type, {address}) { } const Operation* LoadOperation::getAddress() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/AndOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/AndOperation.cpp index 0bab970c..55f6fa39 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/AndOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/AndOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -AndOperation::AndOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::AndOp, identifier, Type::b, leftInput, rightInput) { +AndOperation::AndOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::AndOp, identifier, Type::b, leftInput, rightInput) { } bool AndOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.cpp index 10893781..6c04d3df 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.cpp @@ -3,8 +3,10 @@ #include "nautilus/compiler/ir/operations/LogicalOperations/CompareOperation.hpp" namespace nautilus::compiler::ir { -CompareOperation::CompareOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, Comparator comparator) - : BinaryOperation(Operation::OperationType::CompareOp, identifier, Type::b, leftInput, rightInput), comparator(comparator) { +CompareOperation::CompareOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput, + Comparator comparator) + : BinaryOperation(Operation::OperationType::CompareOp, identifier, Type::b, leftInput, rightInput), + comparator(comparator) { } CompareOperation::Comparator CompareOperation::getComparator() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/NotOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/NotOperation.cpp index 0acb3f08..d1e4d85d 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/NotOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/NotOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -NotOperation::NotOperation(OperationIdentifier identifier, Operation* input) : Operation(OperationType::NotOp, identifier, Type::b, {input}) { +NotOperation::NotOperation(OperationIdentifier identifier, Operation* input) + : Operation(OperationType::NotOp, identifier, Type::b, {input}) { } bool NotOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/OrOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/OrOperation.cpp index 6f5f8dad..8fbd8a8c 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/OrOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/LogicalOperations/OrOperation.cpp @@ -3,7 +3,8 @@ namespace nautilus::compiler::ir { -OrOperation::OrOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) : BinaryOperation(OperationType::OrOp, identifier, Type::b, leftInput, rightInput) { +OrOperation::OrOperation(OperationIdentifier identifier, Operation* leftInput, Operation* rightInput) + : BinaryOperation(OperationType::OrOp, identifier, Type::b, leftInput, rightInput) { } bool OrOperation::classof(const Operation* Op) { diff --git a/nautilus/src/nautilus/compiler/ir/operations/Operation.cpp b/nautilus/src/nautilus/compiler/ir/operations/Operation.cpp index b94771a2..a7f094d6 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/Operation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/Operation.cpp @@ -2,10 +2,13 @@ #include "nautilus/compiler/ir/operations/Operation.hpp" namespace nautilus::compiler::ir { -Operation::Operation(OperationType opType, const OperationIdentifier& identifier, Type stamp, const std::vector& inputs) : opType(opType), identifier(identifier), stamp(stamp), inputs(inputs) { +Operation::Operation(OperationType opType, const OperationIdentifier& identifier, Type stamp, + const std::vector& inputs) + : opType(opType), identifier(identifier), stamp(stamp), inputs(inputs) { } -Operation::Operation(OperationType opType, Type stamp, const std::vector& inputs) : opType(opType), identifier(0), stamp(stamp), inputs(inputs) { +Operation::Operation(OperationType opType, Type stamp, const std::vector& inputs) + : opType(opType), identifier(0), stamp(stamp), inputs(inputs) { } Operation::~Operation() noexcept = default; @@ -60,10 +63,13 @@ bool OperationIdentifier::operator>=(const OperationIdentifier& rhs) const { } bool Operation::isConstOperation() const { - return opType == OperationType::ConstBooleanOp || opType == OperationType::ConstFloatOp || opType == OperationType::ConstIntOp; + return opType == OperationType::ConstBooleanOp || opType == OperationType::ConstFloatOp || + opType == OperationType::ConstIntOp; } -BinaryOperation::BinaryOperation(OperationType opType, const OperationIdentifier& identifier, Type type, Operation* left, Operation* right) : Operation(opType, identifier, type, {left, right}) { +BinaryOperation::BinaryOperation(OperationType opType, const OperationIdentifier& identifier, Type type, + Operation* left, Operation* right) + : Operation(opType, identifier, type, {left, right}) { } Operation* BinaryOperation::getLeftInput() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ProxyCallOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ProxyCallOperation.cpp index 4d2199af..c94576fe 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ProxyCallOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ProxyCallOperation.cpp @@ -3,11 +3,16 @@ #include namespace nautilus::compiler::ir { -ProxyCallOperation::ProxyCallOperation(OperationIdentifier identifier, const std::vector& inputArguments, Type resultType) : Operation(Operation::OperationType::ProxyCallOp, identifier, resultType, inputArguments) { +ProxyCallOperation::ProxyCallOperation(OperationIdentifier identifier, const std::vector& inputArguments, + Type resultType) + : Operation(Operation::OperationType::ProxyCallOp, identifier, resultType, inputArguments) { } -ProxyCallOperation::ProxyCallOperation(const std::string& functionSymbol, const std::string& functionName, void* functionPtr, OperationIdentifier identifier, std::vector inputArguments, Type resultType) - : Operation(Operation::OperationType::ProxyCallOp, identifier, resultType, std::move(inputArguments)), mangedFunctionSymbol(functionSymbol), functionName(functionName), functionPtr(functionPtr) { +ProxyCallOperation::ProxyCallOperation(const std::string& functionSymbol, const std::string& functionName, + void* functionPtr, OperationIdentifier identifier, + std::vector inputArguments, Type resultType) + : Operation(Operation::OperationType::ProxyCallOp, identifier, resultType, std::move(inputArguments)), + mangedFunctionSymbol(functionSymbol), functionName(functionName), functionPtr(functionPtr) { } const std::vector& ProxyCallOperation::getInputArguments() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/ReturnOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/ReturnOperation.cpp index aae6dc58..afeffcaf 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/ReturnOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/ReturnOperation.cpp @@ -7,7 +7,8 @@ namespace nautilus::compiler::ir { ReturnOperation::ReturnOperation() : Operation(Operation::OperationType::ReturnOp, Type::v) { } -ReturnOperation::ReturnOperation(Operation* returnValue) : Operation(Operation::OperationType::ReturnOp, returnValue->getStamp(), {returnValue}) { +ReturnOperation::ReturnOperation(Operation* returnValue) + : Operation(Operation::OperationType::ReturnOp, returnValue->getStamp(), {returnValue}) { } Operation* ReturnOperation::getReturnValue() const { diff --git a/nautilus/src/nautilus/compiler/ir/operations/StoreOperation.cpp b/nautilus/src/nautilus/compiler/ir/operations/StoreOperation.cpp index a043188b..d11a9c65 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/StoreOperation.cpp +++ b/nautilus/src/nautilus/compiler/ir/operations/StoreOperation.cpp @@ -4,7 +4,8 @@ namespace nautilus::compiler::ir { -StoreOperation::StoreOperation(Operation* value, Operation* address) : Operation(OperationType::StoreOp, Type::v, {value, address}) { +StoreOperation::StoreOperation(Operation* value, Operation* address) + : Operation(OperationType::StoreOp, Type::v, {value, address}) { } Operation* StoreOperation::getValue() const { diff --git a/nautilus/src/nautilus/tracing/ExecutionTrace.cpp b/nautilus/src/nautilus/tracing/ExecutionTrace.cpp index cc2bd0f4..06f20b88 100644 --- a/nautilus/src/nautilus/tracing/ExecutionTrace.cpp +++ b/nautilus/src/nautilus/tracing/ExecutionTrace.cpp @@ -51,53 +51,61 @@ bool ExecutionTrace::checkTag(Snapshot& snapshot) { return true; } -void ExecutionTrace::addReturn(Snapshot& snapshot, Type type, value_ref ref) { +void ExecutionTrace::addReturn(Snapshot& snapshot, Type resultType, const TypedValueRef& ref) { if (blocks.empty()) { createBlock(); } auto& operations = blocks[currentBlockIndex].operations; auto op = Op::RETURN; - operations.emplace_back(snapshot, op, type, ref, std::vector {}); + if (ref.type == Type::v) { + operations.emplace_back(snapshot, op, resultType, TypedValueRef(0, Type::v), std::vector {}); + } else { + operations.emplace_back(snapshot, op, resultType, TypedValueRef(0, Type::v), std::vector {ref}); + } auto operationIdentifier = getNextOperationIdentifier(); addTag(snapshot, operationIdentifier); returnRefs.emplace_back(operationIdentifier); } -void ExecutionTrace::addAssignmentOperation(Snapshot& snapshot, nautilus::tracing::value_ref targetRef, nautilus::tracing::value_ref srcRef, Type resultType) { +TypedValueRef& ExecutionTrace::addAssignmentOperation(Snapshot& snapshot, const TypedValueRef& targetRef, + const TypedValueRef& srcRef, Type resultType) { if (blocks.empty()) { createBlock(); } auto& operations = blocks[currentBlockIndex].operations; auto op = ASSIGN; - - operations.emplace_back(snapshot, op, resultType, targetRef, std::vector {srcRef}); + auto& operation = operations.emplace_back(snapshot, op, resultType, targetRef, std::vector {srcRef}); auto operationIdentifier = getNextOperationIdentifier(); addTag(snapshot, operationIdentifier); + return operation.resultRef; } -void ExecutionTrace::addOperation(Snapshot& snapshot, Op& operation, Type& resultType, nautilus::tracing::value_ref targetRef, nautilus::tracing::value_ref srcRef) { +void ExecutionTrace::addOperation(Snapshot& snapshot, Op& operation, std::vector&& inputs) { if (blocks.empty()) { createBlock(); } auto& operations = blocks[currentBlockIndex].operations; - operations.emplace_back(snapshot, operation, resultType, targetRef, std::vector {srcRef}); + operations.emplace_back(snapshot, operation, Type::v, TypedValueRef(0, Type::v), + std::vector {inputs}); } -value_ref ExecutionTrace::addOperationWithResult(Snapshot& snapshot, Op& operation, Type& resultType, std::vector&& inputs) { +TypedValueRef& ExecutionTrace::addOperationWithResult(Snapshot& snapshot, Op& operation, Type& resultType, + std::vector&& inputs) { if (blocks.empty()) { createBlock(); } auto& operations = blocks[currentBlockIndex].operations; - auto& to = operations.emplace_back(snapshot, operation, resultType, value_ref(getNextValueRef(), resultType), std::forward>(inputs)); + auto& to = operations.emplace_back(snapshot, operation, resultType, TypedValueRef(getNextValueRef(), resultType), + std::forward>(inputs)); auto operationIdentifier = getNextOperationIdentifier(); addTag(snapshot, operationIdentifier); return to.resultRef; } -void ExecutionTrace::addCmpOperation(Snapshot& snapshot, value_ref inputs) { +void ExecutionTrace::addCmpOperation(Snapshot& snapshot, const TypedValueRef& inputs) { if (blocks.empty()) { createBlock(); } @@ -108,7 +116,8 @@ void ExecutionTrace::addCmpOperation(Snapshot& snapshot, value_ref inputs) { auto falseBlock = createBlock(); getBlock(falseBlock).predecessors.emplace_back(getCurrentBlockIndex()); auto& operations = blocks[currentBlockIndex].operations; - operations.emplace_back(snapshot, CMP, Type::v, value_ref(getNextValueRef(), Type::v), std::vector {inputs, BlockRef(trueBlock), BlockRef(falseBlock)}); + operations.emplace_back(snapshot, CMP, Type::v, TypedValueRef(getNextValueRef(), Type::v), + std::vector {inputs, BlockRef(trueBlock), BlockRef(falseBlock)}); auto operationIdentifier = getNextOperationIdentifier(); addTag(snapshot, operationIdentifier); } @@ -161,9 +170,9 @@ Block& ExecutionTrace::processControlFlowMerge(operation_identifier oi) { // update in global and local tag map if (sourceOperation.op == RETURN) { - for (size_t i = 0; i < returnRefs.size(); i++) { - if (returnRefs[i].blockIndex == referenceBlock.blockId && returnRefs[i].operationIndex == opIndex) { - returnRefs[i] = operationReference; + for (auto& returnRef : returnRefs) { + if (returnRef.blockIndex == referenceBlock.blockId && returnRef.operationIndex == opIndex) { + returnRef = operationReference; } } } else { @@ -173,7 +182,8 @@ Block& ExecutionTrace::processControlFlowMerge(operation_identifier oi) { } // remove content beyond opID - referenceBlock.operations.erase(referenceBlock.operations.begin() + oi.operationIndex, referenceBlock.operations.end()); + referenceBlock.operations.erase(referenceBlock.operations.begin() + oi.operationIndex, + referenceBlock.operations.end()); // add jump from referenced block to merge block auto mergeBlockRef = BlockRef(mergedBlockId); @@ -200,7 +210,7 @@ Block& ExecutionTrace::processControlFlowMerge(operation_identifier oi) { return mergeBlock; } -value_ref ExecutionTrace::setArgument(Type type, size_t index) { +TypedValueRef& ExecutionTrace::setArgument(Type type, size_t index) { ++lastValueRef; uint16_t argRef = index + 1; auto& arguments = blocks[0].arguments; @@ -208,7 +218,7 @@ value_ref ExecutionTrace::setArgument(Type type, size_t index) { arguments.resize(argRef); } // arguments[index] = {argRef, type}; - arguments[index] = value_ref(argRef, type); + arguments[index] = TypedValueRef(argRef, type); return arguments[index]; } @@ -263,7 +273,8 @@ struct formatter : formatter format_context::iterator; }; -auto formatter::format(const nautilus::tracing::ExecutionTrace& trace, fmt::format_context& ctx) -> format_context::iterator { +auto formatter::format(const nautilus::tracing::ExecutionTrace& trace, + fmt::format_context& ctx) -> format_context::iterator { auto out = ctx.out(); for (size_t i = 0; i < trace.blocks.size(); i++) { fmt::format_to(out, "B{}{}", i, trace.blocks[i]); @@ -271,7 +282,8 @@ auto formatter::format(const nautilus::tracin return out; } -auto formatter::format(const nautilus::tracing::Block& block, format_context& ctx) -> format_context::iterator { +auto formatter::format(const nautilus::tracing::Block& block, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "("); for (size_t i = 0; i < block.arguments.size(); i++) { @@ -293,7 +305,8 @@ auto formatter::format(const nautilus::tracing::Block& template <> struct formatter : formatter { - static auto format(const nautilus::tracing::TypedValueRef& typeValRef, format_context& ctx) -> format_context::iterator { + static auto format(const nautilus::tracing::TypedValueRef& typeValRef, format_context& ctx) + -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "${}", typeValRef.ref); return out; @@ -337,12 +350,13 @@ struct formatter : formatter { auto format(nautilus::ConstantLiteral c, format_context& ctx) const -> format_context::iterator; }; -auto formatter::format(const nautilus::tracing::TraceOperation& operation, format_context& ctx) -> format_context::iterator { +auto formatter::format(const nautilus::tracing::TraceOperation& operation, + format_context& ctx) -> format_context::iterator { auto out = ctx.out(); fmt::format_to(out, "\t{}\t", toString(operation.op)); fmt::format_to(out, "{}\t", operation.resultRef); for (const auto& opInput : operation.input) { - if (auto inputRef = std::get_if(&opInput)) { + if (auto inputRef = std::get_if(&opInput)) { fmt::format_to(out, "{}\t", *inputRef); } else if (auto blockRef = std::get_if(&opInput)) { fmt::format_to(out, "{}\t", *blockRef); diff --git a/nautilus/src/nautilus/tracing/ExecutionTrace.hpp b/nautilus/src/nautilus/tracing/ExecutionTrace.hpp index 74b6caf2..109886d3 100644 --- a/nautilus/src/nautilus/tracing/ExecutionTrace.hpp +++ b/nautilus/src/nautilus/tracing/ExecutionTrace.hpp @@ -18,13 +18,13 @@ class ExecutionTrace { ~ExecutionTrace() = default; - value_ref addOperationWithResult(Snapshot& snapshot, Op& operation, Type& resultType, std::vector&& inputs); + TypedValueRef& addOperationWithResult(Snapshot& snapshot, Op& operation, Type& resultType, std::vector&& inputs); - void addCmpOperation(Snapshot& snapshot, value_ref inputs); + void addCmpOperation(Snapshot& snapshot, const TypedValueRef& inputs); - void addAssignmentOperation(Snapshot&, value_ref targetRef, value_ref srcRef, Type resultType); + TypedValueRef& addAssignmentOperation(Snapshot&, const TypedValueRef& targetRef, const TypedValueRef& srcRef, Type resultType); - void addReturn(Snapshot&, Type type, value_ref ref); + void addReturn(Snapshot&, Type type, const TypedValueRef& ref); bool checkTag(Snapshot& snapshot); @@ -36,7 +36,7 @@ class ExecutionTrace { * @brief Adds arguments that are passed to the traced function * @param argument */ - value_ref setArgument(Type type, size_t index); + TypedValueRef& setArgument(Type type, size_t index); /** * @brief Returns all arguments of this trace. @@ -69,7 +69,7 @@ class ExecutionTrace { */ uint16_t getCurrentBlockIndex() const; - void addOperation(Snapshot& snapshot, Op& operation, Type& resultType, value_ref targetRef, value_ref srcRef); + void addOperation(Snapshot& snapshot, Op& operation, std::vector&& inputs); /** * @brief Returns the current block diff --git a/nautilus/src/nautilus/tracing/TraceContext.cpp b/nautilus/src/nautilus/tracing/TraceContext.cpp index f85cfe09..ddf18102 100644 --- a/nautilus/src/nautilus/tracing/TraceContext.cpp +++ b/nautilus/src/nautilus/tracing/TraceContext.cpp @@ -38,61 +38,35 @@ void TraceContext::terminate() { traceContext = nullptr; } -TraceContext::TraceContext(TagRecorder& tagRecorder) : tagRecorder(tagRecorder), executionTrace(std::make_unique()), symbolicExecutionContext(std::make_unique()) { +TraceContext::TraceContext(TagRecorder& tagRecorder) + : tagRecorder(tagRecorder), executionTrace(std::make_unique()), + symbolicExecutionContext(std::make_unique()) { } -value_ref TraceContext::registerFunctionArgument(Type type, size_t index) { +TypedValueRef& TraceContext::registerFunctionArgument(Type type, size_t index) { return executionTrace->setArgument(type, index); } -void TraceContext::traceValueDestruction(nautilus::tracing::value_ref) { +void TraceContext::traceValueDestruction(nautilus::tracing::TypedValueRef) { // currently yed not implemented } -value_ref TraceContext::traceLoad(const value_ref& src, Type resultType) { - if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == LOAD); - return currentOperation.resultRef; - } - auto op = Op::LOAD; - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - auto resultRef = executionTrace->addOperationWithResult(tag, op, resultType, {src}); - return resultRef; - } - throw TraceTerminationException(); -} - -void TraceContext::traceStore(const value_ref& target, const value_ref& src, Type valueType) { - if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == STORE); - return; - } - auto op = Op::STORE; - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - executionTrace->addOperation(tag, op, valueType, target, src); - return; - } - throw TraceTerminationException(); -} - bool TraceContext::isFollowing() { return symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW; } -value_ref TraceContext::traceConstValue(Type type, const ConstantLiteral& constValue) { +TypedValueRef& TraceContext::follow(Op op) { + auto& currentOperation = executionTrace->getCurrentOperation(); + executionTrace->nextOperation(); + assert(currentOperation.op == op); + return currentOperation.resultRef; +} + +TypedValueRef& TraceContext::traceConstValue(Type type, const ConstantLiteral& constValue) { log::debug("Trace Constant"); auto op = Op::CONST; if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == op); - return currentOperation.resultRef; + return follow(op); } auto tag = recordSnapshot(); auto globalTabIter = executionTrace->globalTagMap.find(tag); @@ -103,130 +77,69 @@ value_ref TraceContext::traceConstValue(Type type, const ConstantLiteral& constV executionTrace->addAssignmentOperation(tag, originalRef.resultRef, resultRef, resultRef.type); return originalRef.resultRef; } else { - auto resultRef = executionTrace->addOperationWithResult(tag, op, type, {constValue}); - return resultRef; + return executionTrace->addOperationWithResult(tag, op, type, {constValue}); } } -value_ref TraceContext::traceCopy(const value_ref& ref) { - log::debug("Trace Copy"); - if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == ASSIGN); - return currentOperation.resultRef; - } - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - auto resultRef = executionTrace->getNextValueRef(); - executionTrace->addAssignmentOperation(tag, {resultRef, ref.type}, ref, ref.type); - return {resultRef, ref.type}; +TypedValueRef& TraceContext::traceOperation(Op op, std::function onCreation) { + if (isFollowing()) { + return follow(op); + } else { + auto tag = recordSnapshot(); + if (executionTrace->checkTag(tag)) { + return onCreation(tag); + } else { + // TODO find a way to handle this more graceful. + throw TraceTerminationException(); + } } - throw TraceTerminationException(); } -value_ref TraceContext::traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, const std::vector& arguments) { +TypedValueRef& TraceContext::traceCopy(const TypedValueRef& ref) { + log::debug("Trace Copy"); + return traceOperation(ASSIGN, [&](Snapshot& tag) -> TypedValueRef& { + auto resultRef = executionTrace->getNextValueRef(); + return executionTrace->addAssignmentOperation(tag, {resultRef, ref.type}, ref, ref.type); + }); +} +TypedValueRef& TraceContext::traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, + Type resultType, const std::vector& arguments) { auto op = Op::CALL; - if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == op); - return currentOperation.resultRef; - } - - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { + return traceOperation(op, [&](Snapshot& tag) -> TypedValueRef& { auto functionArguments = FunctionCall { .functionName = functionName, .mangledName = mangledName, .ptr = fptn, .arguments = arguments, }; - auto resultRef = executionTrace->addOperationWithResult(tag, op, resultType, {functionArguments}); - return resultRef; - } - throw TraceTerminationException(); -} - -void TraceContext::traceAssignment(const value_ref& targetRef, const value_ref& sourceRef, Type resultType) { - if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == ASSIGN); - return; - } - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - executionTrace->addAssignmentOperation(tag, targetRef, sourceRef, resultType); - return; - } - throw TraceTerminationException(); -} - -value_ref TraceContext::traceCast(const value_ref& state, Type resultType) { - if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == CAST); - return currentOperation.resultRef; - } - // TODO is expected? check if we repeat a known trace or if this is a new - // operation. we are in a know operation if the operation at the current - // block[currentOperationCounter] is equal to the received operation. - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - auto op = Op::CAST; - auto resultRef = executionTrace->addOperationWithResult(tag, op, resultType, {state}); - return resultRef; - } - throw TraceTerminationException(); + return executionTrace->addOperationWithResult(tag, op, resultType, {functionArguments}); + }); } -void TraceContext::traceReturnOperation(Type type, const value_ref& ref) { - if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == RETURN); - return; - } - auto tag = recordSnapshot(); - executionTrace->addReturn(tag, type, ref); +void TraceContext::traceAssignment(const TypedValueRef& targetRef, const TypedValueRef& sourceRef, Type resultType) { + traceOperation(ASSIGN, [&](Snapshot& tag) -> TypedValueRef& { + return executionTrace->addAssignmentOperation(tag, targetRef, sourceRef, resultType); + }); } -value_ref TraceContext::traceUnaryOperation(nautilus::tracing::Op op, Type resultType, const value_ref& inputRef) { +void TraceContext::traceReturnOperation(Type resultType, const TypedValueRef& ref) { if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == op); - return currentOperation.resultRef; - } - - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - auto resultRef = executionTrace->addOperationWithResult(tag, op, resultType, {inputRef}); - return resultRef; + follow(RETURN); + } else { + auto tag = recordSnapshot(); + executionTrace->addReturn(tag, resultType, ref); } - throw TraceTerminationException(); } -value_ref TraceContext::traceBinaryOperation(Op op, Type resultType, const value_ref& leftRef, const value_ref& rightRef) { - if (isFollowing()) { - auto& currentOperation = executionTrace->getCurrentOperation(); - executionTrace->nextOperation(); - assert(currentOperation.op == op); - return currentOperation.resultRef; - } - - auto tag = recordSnapshot(); - if (executionTrace->checkTag(tag)) { - auto resultRef = executionTrace->addOperationWithResult(tag, op, resultType, {leftRef, rightRef}); - return resultRef; - } - throw TraceTerminationException(); +TypedValueRef& TraceContext::traceOperation(Op op, Type resultType, std::vector&& inputs) { + return traceOperation(op, [&](Snapshot& tag) -> TypedValueRef& { + return executionTrace->addOperationWithResult(tag, op, resultType, + std::forward>(inputs)); + }); } -bool TraceContext::traceCmp(const value_ref& targetRef) { +bool TraceContext::traceCmp(const TypedValueRef& targetRef) { bool result; if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { // eval execution path one step diff --git a/nautilus/src/nautilus/tracing/TraceContext.hpp b/nautilus/src/nautilus/tracing/TraceContext.hpp index 55e63e35..2e1613c0 100644 --- a/nautilus/src/nautilus/tracing/TraceContext.hpp +++ b/nautilus/src/nautilus/tracing/TraceContext.hpp @@ -40,20 +40,18 @@ class TraceContext { static bool shouldTrace(); - value_ref registerFunctionArgument(Type type, size_t index); + TypedValueRef& registerFunctionArgument(Type type, size_t index); - void traceValueDestruction(value_ref target); + void traceValueDestruction(TypedValueRef target); /** * @brief Trace a constant operation. * @param valueReference reference to the const value. * @param constValue constant value. */ - value_ref traceConstValue(Type type, const ConstantLiteral& constValue); + TypedValueRef& traceConstValue(Type type, const ConstantLiteral& constValue); - value_ref traceCopy(const value_ref& ref); - - Tag* getTag(); + TypedValueRef& traceCopy(const TypedValueRef& ref); /** * @brief Trace a unary operation, e.g., negate. @@ -61,39 +59,24 @@ class TraceContext { * @param inputRef reference to the input. * @param resultRef reference to the result. */ - value_ref traceUnaryOperation(Op op, Type resultType, const value_ref& inputRef); - - /** - * @brief Trace a binary operation, e.g., add, sub, div. - * @param op operation code- - * @param leftRef reference to the left input. - * @param rightRef reference to the right input. - * @param resultRef reference to the result. - */ - value_ref traceBinaryOperation(Op op, Type resultType, const value_ref& leftRef, const value_ref& rightRef); + TypedValueRef& traceOperation(Op op, Type resultType, std::vector&& inputRef); /** * @brief Trace the return function. * @param resultRef referent to the return value. */ - void traceReturnOperation(Type type, const value_ref& ref); + void traceReturnOperation(Type type, const TypedValueRef& ref); /** * @brief Trace a value assignment. * @param targetRef reference to the target value. * @param sourceRef reference to the source value. */ - void traceAssignment(const value_ref& targetRef, const value_ref& sourceRef, Type resultType); + void traceAssignment(const TypedValueRef& targetRef, const TypedValueRef& sourceRef, Type resultType); - value_ref traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, const std::vector& arguments); + TypedValueRef& traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, const std::vector& arguments); - bool traceCmp(const value_ref& targetRef); - - value_ref traceLoad(const value_ref& src, Type resultType); - - value_ref traceCast(const value_ref& state, Type resultType); - - void traceStore(const value_ref& target, const value_ref& src, Type valueType); + bool traceCmp(const TypedValueRef& targetRef); ~TraceContext() = default; @@ -113,7 +96,8 @@ class TraceContext { static void terminate(); bool isFollowing(); - + TypedValueRef& follow(Op op); + TypedValueRef& traceOperation(Op op, std::function onCreation); Snapshot recordSnapshot(); TagRecorder& tagRecorder; diff --git a/nautilus/src/nautilus/tracing/TraceOperation.cpp b/nautilus/src/nautilus/tracing/TraceOperation.cpp index ae3e88ab..24378115 100644 --- a/nautilus/src/nautilus/tracing/TraceOperation.cpp +++ b/nautilus/src/nautilus/tracing/TraceOperation.cpp @@ -5,10 +5,13 @@ namespace nautilus::tracing { BlockRef::BlockRef(uint16_t block) : block(block) { } -TraceOperation::TraceOperation(Snapshot& tag, Op op, Type resultType, value_ref ref, std::vector&& input) : tag(tag), op(op), resultType(resultType), resultRef(ref), input(input) { +TraceOperation::TraceOperation(Snapshot& tag, Op op, Type resultType, TypedValueRef ref, + std::vector&& input) + : tag(tag), op(op), resultType(resultType), resultRef(ref), input(input) { } -TraceOperation::TraceOperation(Op op, std::vector&& input) : tag(), op(op), resultType(Type::v), resultRef(), input(input) { +TraceOperation::TraceOperation(Op op, std::vector&& input) + : tag(), op(op), resultType(Type::v), resultRef(), input(input) { } } // namespace nautilus::tracing diff --git a/nautilus/src/nautilus/tracing/TraceOperation.hpp b/nautilus/src/nautilus/tracing/TraceOperation.hpp index 0d321d6d..635cfa01 100644 --- a/nautilus/src/nautilus/tracing/TraceOperation.hpp +++ b/nautilus/src/nautilus/tracing/TraceOperation.hpp @@ -18,7 +18,7 @@ struct FunctionCall { std::string functionName; std::string mangledName; void* ptr; - std::vector arguments; + std::vector arguments; }; struct BlockRef { @@ -27,19 +27,19 @@ struct BlockRef { std::vector arguments; }; -using InputVariant = std::variant; +using InputVariant = std::variant; /** * @brief Represents an individual operation in a trace. */ class TraceOperation { public: - TraceOperation(Snapshot& tag, Op op, Type resultType, value_ref ref, std::vector&& input); + TraceOperation(Snapshot& tag, Op op, Type resultType, TypedValueRef ref, std::vector&& input); TraceOperation(Op op, std::vector&& input); Snapshot tag; Op op; Type resultType; - value_ref resultRef; + TypedValueRef resultRef; std::vector input; }; diff --git a/nautilus/src/nautilus/tracing/TracingUtil.cpp b/nautilus/src/nautilus/tracing/TracingUtil.cpp index afe46d32..802bde70 100644 --- a/nautilus/src/nautilus/tracing/TracingUtil.cpp +++ b/nautilus/src/nautilus/tracing/TracingUtil.cpp @@ -20,13 +20,13 @@ std::string getMangledName(void* fnptr) { } std::string getFunctionName(const std::string& mangledName) { - std::size_t sz = 25; - char* buffer = static_cast(std::malloc(sz)); - int status; - char* realname = abi::__cxa_demangle(mangledName.c_str(), buffer, &sz, &status); - if (realname) { - return realname; - } + //std::size_t sz = 25; + //char* buffer = static_cast(std::malloc(sz)); + //int status; + //char* realname = abi::__cxa_demangle(mangledName.c_str(), buffer, &sz, &status); + //if (realname) { + // return realname; + //} return mangledName; } @@ -42,19 +42,11 @@ void traceReturnOperation(Type type, const TypedValueRef& ref) { TraceContext::get()->traceReturnOperation(type, ref); } -value_ref registerFunctionArgument(Type type, size_t index) { +TypedValueRef& registerFunctionArgument(Type type, size_t index) { return TraceContext::get()->registerFunctionArgument(type, index); } -value_ref traceLoad(const TypedValueRef& src, Type resultType) { - return TraceContext::get()->traceLoad(src, resultType); -} - -void traceStore(const TypedValueRef& target, const TypedValueRef& src, Type valueType) { - TraceContext::get()->traceStore(target, src, valueType); -} - -value_ref traceConstant(Type type, const ConstantLiteral& value) { +TypedValueRef& traceConstant(Type type, const ConstantLiteral& value) { return TraceContext::get()->traceConstValue(type, value); } @@ -62,10 +54,6 @@ bool traceBool(const TypedValueRef& state) { return TraceContext::get()->traceCmp(state); } -value_ref traceCast(const TypedValueRef& state, Type resultType) { - return TraceContext::get()->traceCast(state, resultType); -} - void allocateValRef(ValueRef ref) { TraceContext::get()->allocateValRef(ref); } @@ -73,7 +61,7 @@ void freeValRef(ValueRef ref) { TraceContext::get()->freeValRef(ref); } -value_ref traceCopy(const value_ref& state) { +TypedValueRef traceCopy(const TypedValueRef& state) { if (inTracer()) { return TraceContext::get()->traceCopy(state); } @@ -84,18 +72,18 @@ bool inTracer() { return TraceContext::get() != nullptr; } -value_ref traceCall(void* fptn, Type resultType, const std::vector& arguments) { +TypedValueRef& traceCall(void* fptn, Type resultType, const std::vector& arguments) { auto mangledName = getMangledName(fptn); auto functionName = getFunctionName(mangledName); return TraceContext::get()->traceCall(functionName, mangledName, fptn, resultType, arguments); } -value_ref traceBinaryOp(Op operation, Type resultType, const TypedValueRef& leftState, const TypedValueRef& rightState) { - return TraceContext::get()->traceBinaryOperation(operation, resultType, leftState, rightState); +TypedValueRef& traceBinaryOp(Op operation, Type resultType, const TypedValueRef& left, const TypedValueRef& right) { + return TraceContext::get()->traceOperation(operation, resultType, {left, right}); } -value_ref traceUnaryOp(Op operation, Type resultType, const TypedValueRef& inputState) { - return TraceContext::get()->traceUnaryOperation(operation, resultType, inputState); +TypedValueRef& traceUnaryOp(Op operation, Type resultType, const TypedValueRef& input) { + return TraceContext::get()->traceOperation(operation, resultType, {input}); } std::ostream& operator<<(std::ostream& os, const Op& operation) { @@ -131,7 +119,8 @@ struct formatter : formatter { }; } // namespace fmt -auto fmt::formatter::format(nautilus::ConstantLiteral lit, format_context& ctx) const -> format_context::iterator { +auto fmt::formatter::format(nautilus::ConstantLiteral lit, format_context& ctx) const + -> format_context::iterator { auto out = ctx.out(); std::visit( [&](auto&& value) { diff --git a/nautilus/src/nautilus/tracing/phases/SSACreationPhase.cpp b/nautilus/src/nautilus/tracing/phases/SSACreationPhase.cpp index fe7df6cd..bdf194a6 100644 --- a/nautilus/src/nautilus/tracing/phases/SSACreationPhase.cpp +++ b/nautilus/src/nautilus/tracing/phases/SSACreationPhase.cpp @@ -13,7 +13,8 @@ std::shared_ptr SSACreationPhase::apply(std::shared_ptr trace) : trace(std::move(trace)) { +SSACreationPhase::SSACreationPhaseContext::SSACreationPhaseContext(std::shared_ptr trace) + : trace(std::move(trace)) { } Block& SSACreationPhase::SSACreationPhaseContext::getReturnBlock() { @@ -31,11 +32,14 @@ Block& SSACreationPhase::SSACreationPhaseContext::getReturnBlock() { for (auto returnOp : returns) { auto& returnOpBlock = trace->getBlock(returnOp.blockIndex); auto returnValue = returnOpBlock.operations[returnOp.operationIndex]; - if (returnValue.resultType == Type::v) { + // check if we have return values + if (returnValue.input.empty()) { returnOpBlock.operations.erase(returnOpBlock.operations.cbegin() + returnOp.operationIndex); } else { auto snap = Snapshot(); - returnOpBlock.operations[returnOp.operationIndex] = TraceOperation(snap, ASSIGN, defaultReturnOp.resultType, defaultReturnOp.resultRef, {returnValue.resultRef}); + returnOpBlock.operations[returnOp.operationIndex] = + TraceOperation(snap, ASSIGN, defaultReturnOp.resultType, + std::get(defaultReturnOp.input[0]), {returnValue.input[0]}); } returnOpBlock.addOperation({Op::JMP, std::vector {BlockRef(returnBlock.blockId)}}); returnBlock.predecessors.emplace_back(returnOp.blockIndex); @@ -62,7 +66,8 @@ std::shared_ptr SSACreationPhase::SSACreationPhaseContext::proce // check arguments if (rootBlockNumberOfArguments != trace->getBlocks().front().arguments.size()) { - throw RuntimeException(fmt::format("Wrong number of arguments in trace: expected {}, got {}\n", rootBlockNumberOfArguments, trace->getBlocks().front().arguments.size())); + throw RuntimeException(fmt::format("Wrong number of arguments in trace: expected {}, got {}\n", + rootBlockNumberOfArguments, trace->getBlocks().front().arguments.size())); } // sort arguments std::sort(trace->getBlocks().front().arguments.begin(), trace->getBlocks().front().arguments.end()); @@ -70,7 +75,8 @@ std::shared_ptr SSACreationPhase::SSACreationPhaseContext::proce return std::move(trace); } -bool SSACreationPhase::SSACreationPhaseContext::isLocalValueRef(Block& block, value_ref& ref, Type, uint32_t operationIndex) { +bool SSACreationPhase::SSACreationPhaseContext::isLocalValueRef(Block& block, TypedValueRef& ref, Type, + uint32_t operationIndex) { // A value ref is defined in the local scope, if it is the result of an // operation before the operationIndex for (uint32_t i = 0; i < operationIndex; i++) { @@ -89,11 +95,8 @@ void SSACreationPhase::SSACreationPhaseContext::processBlock(Block& block) { for (int64_t i = block.operations.size() - 1; i >= 0; i--) { auto& operation = block.operations[i]; // process input for each variable - if (operation.op == RETURN && operation.resultType != Type::v) { - processValueRef(block, operation.resultRef, operation.resultType, i); - } for (auto& input : operation.input) { - if (auto* valueRef = std::get_if(&input)) { + if (auto* valueRef = std::get_if(&input)) { // set op type processValueRef(block, *valueRef, operation.resultType, i); } else if (auto* blockRef = std::get_if(&input)) { @@ -104,10 +107,6 @@ void SSACreationPhase::SSACreationPhaseContext::processBlock(Block& block) { } } } - - if (operation.op == STORE) { - processValueRef(block, operation.resultRef, operation.resultType, i); - } } processedBlocks.emplace(block.blockId); // Recursively process the predecessors of this block @@ -122,7 +121,8 @@ void SSACreationPhase::SSACreationPhaseContext::processBlock(Block& block) { } } -void SSACreationPhase::SSACreationPhaseContext::processValueRef(Block& block, value_ref& ref, Type ref_type, uint32_t operationIndex) { +void SSACreationPhase::SSACreationPhaseContext::processValueRef(Block& block, TypedValueRef& ref, Type ref_type, + uint32_t operationIndex) { if (isLocalValueRef(block, ref, ref_type, operationIndex)) { // variable is a local ref -> don't do anything as the value is defined in // the current block @@ -157,7 +157,8 @@ void SSACreationPhase::SSACreationPhaseContext::processValueRef(Block& block, va } } -void SSACreationPhase::SSACreationPhaseContext::processBlockRef(Block& block, BlockRef& blockRef, uint32_t operationIndex) { +void SSACreationPhase::SSACreationPhaseContext::processBlockRef(Block& block, BlockRef& blockRef, + uint32_t operationIndex) { // a block ref has a set of arguments, which are handled the same as all other // value references. for (auto& input : blockRef.arguments) { @@ -169,64 +170,34 @@ void SSACreationPhase::SSACreationPhaseContext::removeAssignOperations() { // Iterate over all block and eliminate the ASSIGN operation. for (Block& block : trace->getBlocks()) { std::unordered_map assignmentMap; - for (uint64_t i = 0; i < block.operations.size(); i++) { - auto& operation = block.operations[i]; - if (operation.op == Op::CMP) { - if (auto valueRef = &operation.resultRef) { - auto foundAssignment = assignmentMap.find(valueRef->ref); - if (foundAssignment != assignmentMap.end()) { - // todo check assignment - valueRef->ref = foundAssignment->second; - } - } - } + for (auto& operation : block.operations) { if (operation.op == Op::ASSIGN) { - auto valueRef = get(operation.input[0]); + auto& valueRef = get(operation.input[0]); auto foundAssignment = assignmentMap.find(valueRef.ref); if (foundAssignment != assignmentMap.end()) { - assignmentMap[operation.resultRef.ref] = assignmentMap[valueRef.ref]; + assignmentMap[operation.resultRef.ref] = foundAssignment->second; } else { - assignmentMap[operation.resultRef.ref] = get(operation.input[0]).ref; - } - } else if (operation.op == Op::RETURN) { - auto foundAssignment = assignmentMap.find(operation.resultRef.ref); - if (foundAssignment != assignmentMap.end()) { - operation.resultRef.ref = foundAssignment->second; + assignmentMap[operation.resultRef.ref] = get(operation.input[0]).ref; } } else { - if (operation.op == Op::STORE) { - auto foundAssignment = assignmentMap.find(operation.resultRef.ref); - if (foundAssignment != assignmentMap.end()) { - operation.resultRef.ref = foundAssignment->second; - } - } for (auto& input : operation.input) { - if (auto* valueRef = std::get_if(&input)) { + if (auto* valueRef = std::get_if(&input)) { auto foundAssignment = assignmentMap.find(valueRef->ref); if (foundAssignment != assignmentMap.end()) { - // todo check assignment valueRef->ref = foundAssignment->second; - // valueRef->blockId = foundAssignment->second.blockId; - // valueRef->operationId = foundAssignment->second.operationId; } } else if (auto* blockRef = std::get_if(&input)) { for (auto& blockArgument : blockRef->arguments) { auto foundAssignment = assignmentMap.find(blockArgument.ref); if (foundAssignment != assignmentMap.end()) { - // valueRef = &foundAssignment->second; blockArgument.ref = foundAssignment->second; - // blockArgument.operationId = - // foundAssignment->second.operationId; } } } else if (auto* fcallRef = std::get_if(&input)) { for (auto& funcArg : fcallRef->arguments) { auto foundAssignment = assignmentMap.find(funcArg.ref); if (foundAssignment != assignmentMap.end()) { - // valueRef = &foundAssignment->second; funcArg.ref = foundAssignment->second; - // blockArgument.operationId = - // foundAssignment->second.operationId; } } } @@ -245,7 +216,7 @@ void SSACreationPhase::SSACreationPhaseContext::makeBlockArgumentsUnique() { for (uint64_t i = 0; i < block.operations.size(); i++) { auto& operation = block.operations[i]; for (auto& input : operation.input) { - if (auto* valueRef = std::get_if(&input)) { + if (auto* valueRef = std::get_if(&input)) { auto foundAssignment = blockArgumentMap.find(valueRef->ref); if (foundAssignment != blockArgumentMap.end()) { // todo check assignment diff --git a/nautilus/src/nautilus/tracing/phases/SSACreationPhase.hpp b/nautilus/src/nautilus/tracing/phases/SSACreationPhase.hpp index c692837d..7df62c44 100644 --- a/nautilus/src/nautilus/tracing/phases/SSACreationPhase.hpp +++ b/nautilus/src/nautilus/tracing/phases/SSACreationPhase.hpp @@ -54,9 +54,9 @@ class SSACreationPhase { * @param operationIndex the operation index, which accesses the ValueRef * @return true if Value Ref is defined locally. */ - static bool isLocalValueRef(Block& block, value_ref& valRef, Type ref_type, uint32_t operationIndex); + static bool isLocalValueRef(Block& block, TypedValueRef& valRef, Type ref_type, uint32_t operationIndex); - void processValueRef(Block& block, value_ref& type, Type ref_type, uint32_t operationIndex); + void processValueRef(Block& block, TypedValueRef& type, Type ref_type, uint32_t operationIndex); void processBlockRef(Block& block, BlockRef& blockRef, uint32_t operationIndex); diff --git a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp index bb1ef2c3..1ee40fff 100644 --- a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp +++ b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp @@ -20,25 +20,32 @@ namespace nautilus::tracing { using namespace compiler::ir; -OperationIdentifier createValueIdentifier(value_ref& val) { +OperationIdentifier createValueIdentifier(TypedValueRef& val) { return {val.ref}; } OperationIdentifier createValueIdentifier(InputVariant& val) { - if (auto* valRef = std::get_if(&val)) { + if (auto* valRef = std::get_if(&val)) { return {valRef->ref}; } throw NotImplementedException("wrong input variant"); } -std::shared_ptr TraceToIRConversionPhase::apply(std::shared_ptr trace, const compiler::CompilationUnitID& id) { +std::shared_ptr TraceToIRConversionPhase::apply(std::shared_ptr trace, + const compiler::CompilationUnitID& id) { auto phaseContext = IRConversionContext(std::move(trace), id); return phaseContext.process(); } +TraceToIRConversionPhase::IRConversionContext::IRConversionContext(std::shared_ptr trace, + const compiler::CompilationUnitID& id) + : trace(trace), ir(std::make_shared(id)) { +} + std::shared_ptr TraceToIRConversionPhase::IRConversionContext::process() { processBlock(trace->getBlocks().front()); - auto functionOperation = std::make_unique("execute", currentBasicBlocks, std::vector {}, std::vector {}, returnType); + auto functionOperation = std::make_unique("execute", currentBasicBlocks, std::vector {}, + std::vector {}, returnType); ir->addRootOperation(std::move(functionOperation)); return ir; } @@ -63,7 +70,9 @@ BasicBlock* TraceToIRConversionPhase::IRConversionContext::processBlock(Block& b return irBasicBlockPtr; } -void TraceToIRConversionPhase::IRConversionContext::processOperation(ValueFrame& frame, Block& currentBlock, BasicBlock*& currentIrBlock, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processOperation(ValueFrame& frame, Block& currentBlock, + BasicBlock*& currentIrBlock, + TraceOperation& operation) { switch (operation.op) { case Op::ADD: { @@ -139,12 +148,13 @@ void TraceToIRConversionPhase::IRConversionContext::processOperation(ValueFrame& return; } case Op::RETURN: { - returnType = operation.resultType; - if (returnType == Type::v) { + if (operation.input.empty()) { currentIrBlock->addOperation(); + returnType = Type::v; } else { - auto returnValue = frame.getValue(createValueIdentifier(operation.resultRef)); + auto returnValue = frame.getValue(createValueIdentifier(operation.input[0])); currentIrBlock->addOperation(returnValue); + returnType = returnValue->getStamp(); } return; } @@ -185,7 +195,9 @@ void TraceToIRConversionPhase::IRConversionContext::processOperation(ValueFrame& } template -void TraceToIRConversionPhase::IRConversionContext::processBinaryOperator(ValueFrame& frame, compiler::ir::BasicBlock* currentBlock, TraceOperation& op) { +void TraceToIRConversionPhase::IRConversionContext::processBinaryOperator(ValueFrame& frame, + compiler::ir::BasicBlock* currentBlock, + TraceOperation& op) { auto leftInput = frame.getValue(createValueIdentifier(op.input[0])); auto rightInput = frame.getValue(createValueIdentifier(op.input[1])); auto resultIdentifier = createValueIdentifier(op.resultRef); @@ -194,14 +206,17 @@ void TraceToIRConversionPhase::IRConversionContext::processBinaryOperator(ValueF } template -void TraceToIRConversionPhase::IRConversionContext::processUnaryOperator(ValueFrame& frame, compiler::ir::BasicBlock* currentBlock, TraceOperation& op) { +void TraceToIRConversionPhase::IRConversionContext::processUnaryOperator(ValueFrame& frame, + compiler::ir::BasicBlock* currentBlock, + TraceOperation& op) { auto input = frame.getValue(createValueIdentifier(op.input[0])); auto resultIdentifier = createValueIdentifier(op.resultRef); auto operation = currentBlock->addOperation(resultIdentifier, input); frame.setValue(resultIdentifier, operation); } -void TraceToIRConversionPhase::IRConversionContext::processJMP(ValueFrame& frame, BasicBlock* block, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processJMP(ValueFrame& frame, BasicBlock* block, + TraceOperation& operation) { auto blockRef = get(operation.input[0]); BasicBlockInvocation blockInvocation; createBlockArguments(frame, blockInvocation, blockRef); @@ -217,8 +232,9 @@ void TraceToIRConversionPhase::IRConversionContext::processJMP(ValueFrame& frame block->addNextBlock(resultTargetBlock, blockInvocation.getArguments()); } -void TraceToIRConversionPhase::IRConversionContext::processCMP(ValueFrame& frame, Block&, BasicBlock* currentIrBlock, TraceOperation& operation) { - auto valueRef = get(operation.input[0]); +void TraceToIRConversionPhase::IRConversionContext::processCMP(ValueFrame& frame, Block&, BasicBlock* currentIrBlock, + TraceOperation& operation) { + auto valueRef = get(operation.input[0]); auto trueCaseBlockRef = get(operation.input[1]); auto falseCaseBlockRef = get(operation.input[2]); @@ -235,14 +251,19 @@ void TraceToIRConversionPhase::IRConversionContext::processCMP(ValueFrame& frame currentIrBlock->addOperation(std::move(ifOperation)); } -void TraceToIRConversionPhase::IRConversionContext::createBlockArguments(ValueFrame& frame, BasicBlockInvocation& blockInvocation, BlockRef val) { +void TraceToIRConversionPhase::IRConversionContext::createBlockArguments(ValueFrame& frame, + BasicBlockInvocation& blockInvocation, + BlockRef val) { for (auto& arg : val.arguments) { auto valueIdentifier = createValueIdentifier(arg); blockInvocation.addArgument(frame.getValue(valueIdentifier)); } } -void TraceToIRConversionPhase::IRConversionContext::processBinaryComp(ValueFrame& frame, compiler::ir::BasicBlock* currentBlock, nautilus::tracing::TraceOperation& operation, compiler::ir::BinaryCompOperation::Type type) { +void TraceToIRConversionPhase::IRConversionContext::processBinaryComp(ValueFrame& frame, + compiler::ir::BasicBlock* currentBlock, + nautilus::tracing::TraceOperation& operation, + compiler::ir::BinaryCompOperation::Type type) { auto leftInput = frame.getValue(createValueIdentifier(operation.input[0])); auto rightInput = frame.getValue(createValueIdentifier(operation.input[1])); auto resultIdentifier = createValueIdentifier(operation.resultRef); @@ -250,7 +271,10 @@ void TraceToIRConversionPhase::IRConversionContext::processBinaryComp(ValueFrame frame.setValue(resultIdentifier, divOperation); } -void TraceToIRConversionPhase::IRConversionContext::processShift(ValueFrame& frame, compiler::ir::BasicBlock* currentBlock, nautilus::tracing::TraceOperation& operation, compiler::ir::ShiftOperation::ShiftType type) { +void TraceToIRConversionPhase::IRConversionContext::processShift(ValueFrame& frame, + compiler::ir::BasicBlock* currentBlock, + nautilus::tracing::TraceOperation& operation, + compiler::ir::ShiftOperation::ShiftType type) { auto leftInput = frame.getValue(createValueIdentifier(operation.input[0])); auto rightInput = frame.getValue(createValueIdentifier(operation.input[1])); auto resultIdentifier = createValueIdentifier(operation.resultRef); @@ -258,7 +282,10 @@ void TraceToIRConversionPhase::IRConversionContext::processShift(ValueFrame& fra frame.setValue(resultIdentifier, divOperation); } -void TraceToIRConversionPhase::IRConversionContext::processLogicalComperator(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation, CompareOperation::Comparator comp) { +void TraceToIRConversionPhase::IRConversionContext::processLogicalComperator(ValueFrame& frame, + BasicBlock* currentBlock, + TraceOperation& operation, + CompareOperation::Comparator comp) { auto leftInput = frame.getValue(createValueIdentifier(operation.input[0])); auto rightInput = frame.getValue(createValueIdentifier(operation.input[1])); auto resultIdentifier = createValueIdentifier(operation.resultRef); @@ -266,7 +293,8 @@ void TraceToIRConversionPhase::IRConversionContext::processLogicalComperator(Val frame.setValue(resultIdentifier, compareOperation); } -void TraceToIRConversionPhase::IRConversionContext::processLoad(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processLoad(ValueFrame& frame, BasicBlock* currentBlock, + TraceOperation& operation) { auto address = frame.getValue(createValueIdentifier(operation.input[0])); auto resultIdentifier = createValueIdentifier(operation.resultRef); auto resultType = operation.resultType; @@ -275,13 +303,15 @@ void TraceToIRConversionPhase::IRConversionContext::processLoad(ValueFrame& fram currentBlock->addOperation(std::move(loadOperation)); } -void TraceToIRConversionPhase::IRConversionContext::processStore(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { - auto address = frame.getValue(createValueIdentifier(operation.resultRef)); - auto value = frame.getValue(createValueIdentifier(operation.input[0])); +void TraceToIRConversionPhase::IRConversionContext::processStore(ValueFrame& frame, BasicBlock* currentBlock, + TraceOperation& operation) { + auto address = frame.getValue(createValueIdentifier(operation.input[0])); + auto value = frame.getValue(createValueIdentifier(operation.input[1])); currentBlock->addOperation(value, address); } -void TraceToIRConversionPhase::IRConversionContext::processCall(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processCall(ValueFrame& frame, BasicBlock* currentBlock, + TraceOperation& operation) { auto functionCallTarget = std::get(operation.input[0]); auto inputArguments = std::vector {}; for (auto& argument : functionCallTarget.arguments) { @@ -291,13 +321,16 @@ void TraceToIRConversionPhase::IRConversionContext::processCall(ValueFrame& fram auto resultType = operation.resultType; auto resultIdentifier = createValueIdentifier(operation.resultRef); - auto proxyCallOperation = currentBlock->addOperation(functionCallTarget.mangledName, functionCallTarget.functionName, functionCallTarget.ptr, resultIdentifier, inputArguments, resultType); + auto proxyCallOperation = currentBlock->addOperation( + functionCallTarget.mangledName, functionCallTarget.functionName, functionCallTarget.ptr, resultIdentifier, + inputArguments, resultType); if (resultType != Type::v) { frame.setValue(resultIdentifier, proxyCallOperation); } } -void TraceToIRConversionPhase::IRConversionContext::processConst(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processConst(ValueFrame& frame, BasicBlock* currentBlock, + TraceOperation& operation) { auto constant = std::get(operation.input[0]); auto resultIdentifier = createValueIdentifier(operation.resultRef); auto resultType = operation.resultType; @@ -322,7 +355,8 @@ void TraceToIRConversionPhase::IRConversionContext::processConst(ValueFrame& fra frame.setValue(resultIdentifier, constOperation); } -void TraceToIRConversionPhase::IRConversionContext::processCast(ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { +void TraceToIRConversionPhase::IRConversionContext::processCast(ValueFrame& frame, BasicBlock* currentBlock, + TraceOperation& operation) { auto resultIdentifier = createValueIdentifier(operation.resultRef); auto input = frame.getValue(createValueIdentifier(operation.input[0])); auto castOperation = currentBlock->addOperation(resultIdentifier, input, operation.resultType); diff --git a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.hpp b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.hpp index 62b0bc98..2d6882dd 100644 --- a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.hpp +++ b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.hpp @@ -45,8 +45,7 @@ class TraceToIRConversionPhase { */ class IRConversionContext { public: - IRConversionContext(std::shared_ptr trace, const compiler::CompilationUnitID& id) : trace(trace), ir(std::make_shared(id)) { - } + IRConversionContext(std::shared_ptr trace, const compiler::CompilationUnitID& id); std::shared_ptr process(); diff --git a/nautilus/src/nautilus/tracing/symbolic_execution/SymbolicExecutionContext.cpp b/nautilus/src/nautilus/tracing/symbolic_execution/SymbolicExecutionContext.cpp index 0d54a252..684d1ebb 100644 --- a/nautilus/src/nautilus/tracing/symbolic_execution/SymbolicExecutionContext.cpp +++ b/nautilus/src/nautilus/tracing/symbolic_execution/SymbolicExecutionContext.cpp @@ -59,7 +59,8 @@ bool SymbolicExecutionContext::follow() { } bool SymbolicExecutionContext::shouldFollow() { - return currentMode == SymbolicExecutionContext::MODE::FOLLOW && currentOperation < currentExecutionPath.getSize() - 1; + return currentMode == SymbolicExecutionContext::MODE::FOLLOW && + currentOperation < currentExecutionPath.getSize() - 1; } bool SymbolicExecutionContext::shouldContinue() { diff --git a/nautilus/test/benchmark/TracingBenchmark.cpp b/nautilus/test/benchmark/TracingBenchmark.cpp index d02cc8d1..45aeb7f8 100644 --- a/nautilus/test/benchmark/TracingBenchmark.cpp +++ b/nautilus/test/benchmark/TracingBenchmark.cpp @@ -39,7 +39,9 @@ TEST_CASE("Tracing Benchmark") { for (auto& test : tests) { auto func = std::get<1>(test); auto name = std::get<0>(test); - Catch::Benchmark::Benchmark("trace_" + name).operator=([&func](Catch::Benchmark::Chronometer meter) { meter.measure([&func] { return tracing::TraceContext::trace(func); }); }); + Catch::Benchmark::Benchmark("trace_" + name).operator=([&func](Catch::Benchmark::Chronometer meter) { + meter.measure([&func] { return tracing::TraceContext::trace(func); }); + }); } } @@ -100,20 +102,22 @@ TEST_CASE("Backend Compilation Benchmark") { auto func = std::get<1>(test); auto name = std::get<0>(test); - Catch::Benchmark::Benchmark("comp_" + backend + "_" + name).operator=([&func, ®istry, backend](Catch::Benchmark::Chronometer meter) { - std::shared_ptr trace = tracing::TraceContext::trace(func); - auto ssaCreationPhase = tracing::SSACreationPhase(); - trace = ssaCreationPhase.apply(trace); - auto backendBackend = registry.getBackend(backend); - auto irConversionPhase = tracing::TraceToIRConversionPhase(); - auto ir = irConversionPhase.apply(trace); - auto op = engine::Options(); - // force compilation for the MLIR backend. - op.setOption("mlir.eager_compilation", true); - op.setOption("engine.backend", backend); - auto dh = compiler::DumpHandler(op, ""); - meter.measure([&] { return backendBackend->compile(ir, dh, op); }); - }); + Catch::Benchmark::Benchmark("comp_" + backend + "_" + name) + . + operator=([&func, ®istry, backend](Catch::Benchmark::Chronometer meter) { + std::shared_ptr trace = tracing::TraceContext::trace(func); + auto ssaCreationPhase = tracing::SSACreationPhase(); + trace = ssaCreationPhase.apply(trace); + auto backendBackend = registry.getBackend(backend); + auto irConversionPhase = tracing::TraceToIRConversionPhase(); + auto ir = irConversionPhase.apply(trace); + auto op = engine::Options(); + // force compilation for the MLIR backend. + op.setOption("mlir.eager_compilation", true); + op.setOption("engine.backend", backend); + auto dh = compiler::DumpHandler(op, ""); + meter.measure([&] { return backendBackend->compile(ir, dh, op); }); + }); } } } diff --git a/nautilus/test/common/TracingUtil.hpp b/nautilus/test/common/TracingUtil.hpp index 4d150107..99e6717f 100644 --- a/nautilus/test/common/TracingUtil.hpp +++ b/nautilus/test/common/TracingUtil.hpp @@ -14,7 +14,7 @@ std::function createFunctionWrapper(std::index_sequence, R ( auto traceFunc = [=]() { if constexpr (std::is_void_v) { fnptr(details::createTraceableArgument()...); - tracing::traceReturnOperation(Type::v, tracing::value_ref()); + tracing::traceReturnOperation(Type::v, tracing::TypedValueRef()); } else { auto returnValue = fnptr(details::createTraceableArgument()...); auto type = tracing::to_type(); @@ -28,4 +28,4 @@ template std::function createFunctionWrapper(R (*fnptr)(FunctionArguments...)) { return createFunctionWrapper(std::make_index_sequence {}, fnptr); } -}} // namespace nautilus::details \ No newline at end of file +}} // namespace nautilus::details diff --git a/nautilus/test/data/bool-tests/after_ssa/boolAnd.trace b/nautilus/test/data/bool-tests/after_ssa/boolAnd.trace index 309979e5..9b6163a9 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolAnd.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolAnd.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) AND $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolAssignment.trace b/nautilus/test/data/bool-tests/after_ssa/boolAssignment.trace index a527c7ec..8d21d690 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolAssignment.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolAssignment.trace @@ -1,2 +1,2 @@ B0($1:bool) - RETURN $1 :bool + RETURN $0 $1 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolAssignmentOr.trace b/nautilus/test/data/bool-tests/after_ssa/boolAssignmentOr.trace index fbc6e91b..407001a7 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolAssignmentOr.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolAssignmentOr.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) OR $6 $1 $2 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolConst.trace b/nautilus/test/data/bool-tests/after_ssa/boolConst.trace index ed20f465..4a0bad21 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolConst.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolConst.trace @@ -1,4 +1,4 @@ B0($1:bool) CONST $3 true :bool AND $4 $1 $3 :bool - RETURN $4 :bool + RETURN $0 $4 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolEquals.trace b/nautilus/test/data/bool-tests/after_ssa/boolEquals.trace index 3ecedcf5..15184ff5 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolEquals.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolEquals.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) EQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace b/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace index b59ce876..84c9e638 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace @@ -8,4 +8,4 @@ B2() CONST $10 false :bool JMP $0 B3($10) :void B3($7:bool) - RETURN $7 :bool + RETURN $0 $7 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace b/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace index 2ca2d58f..007c5e4b 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace @@ -8,4 +8,4 @@ B2() CONST $10 false :bool JMP $0 B3($10) :void B3($7:bool) - RETURN $7 :bool + RETURN $0 $7 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolNot.trace b/nautilus/test/data/bool-tests/after_ssa/boolNot.trace index 79f08759..7a3c8c72 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolNot.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolNot.trace @@ -1,3 +1,3 @@ B0($1:bool) NOT $3 $1 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolNotEquals.trace b/nautilus/test/data/bool-tests/after_ssa/boolNotEquals.trace index 915cacfb..ed11df13 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolNotEquals.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolNotEquals.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) NEQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolOr.trace b/nautilus/test/data/bool-tests/after_ssa/boolOr.trace index e481fa59..66fac2ef 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolOr.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolOr.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) OR $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolAnd.trace b/nautilus/test/data/bool-tests/tracing/boolAnd.trace index 3f428c30..cb65defb 100644 --- a/nautilus/test/data/bool-tests/tracing/boolAnd.trace +++ b/nautilus/test/data/bool-tests/tracing/boolAnd.trace @@ -2,4 +2,4 @@ B0($1:bool,$2:bool) ASSIGN $3 $1 :bool ASSIGN $4 $2 :bool AND $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolAssignment.trace b/nautilus/test/data/bool-tests/tracing/boolAssignment.trace index d38cd100..a738551b 100644 --- a/nautilus/test/data/bool-tests/tracing/boolAssignment.trace +++ b/nautilus/test/data/bool-tests/tracing/boolAssignment.trace @@ -1,3 +1,3 @@ B0($1:bool) ASSIGN $2 $1 :bool - RETURN $2 :bool + RETURN $0 $2 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolAssignmentOr.trace b/nautilus/test/data/bool-tests/tracing/boolAssignmentOr.trace index 60c1fef0..2f010a1f 100644 --- a/nautilus/test/data/bool-tests/tracing/boolAssignmentOr.trace +++ b/nautilus/test/data/bool-tests/tracing/boolAssignmentOr.trace @@ -4,4 +4,4 @@ B0($1:bool,$2:bool) ASSIGN $4 $3 :bool ASSIGN $5 $2 :bool OR $6 $4 $5 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolConst.trace b/nautilus/test/data/bool-tests/tracing/boolConst.trace index 33045c35..badc985f 100644 --- a/nautilus/test/data/bool-tests/tracing/boolConst.trace +++ b/nautilus/test/data/bool-tests/tracing/boolConst.trace @@ -2,4 +2,4 @@ B0($1:bool) ASSIGN $2 $1 :bool CONST $3 true :bool AND $4 $2 $3 :bool - RETURN $4 :bool + RETURN $0 $4 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolEquals.trace b/nautilus/test/data/bool-tests/tracing/boolEquals.trace index 3ecedcf5..15184ff5 100644 --- a/nautilus/test/data/bool-tests/tracing/boolEquals.trace +++ b/nautilus/test/data/bool-tests/tracing/boolEquals.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) EQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolIfElse.trace b/nautilus/test/data/bool-tests/tracing/boolIfElse.trace index a1872d2f..549b0dd3 100644 --- a/nautilus/test/data/bool-tests/tracing/boolIfElse.trace +++ b/nautilus/test/data/bool-tests/tracing/boolIfElse.trace @@ -5,7 +5,7 @@ B0($1:bool,$2:bool) CMP $6 $5 B1() B2() :void B1() CONST $7 true :bool - RETURN $7 :bool + RETURN $0 $7 :bool B2() CONST $10 false :bool - RETURN $10 :bool + RETURN $0 $10 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace b/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace index 583d61af..ab0d4891 100644 --- a/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace +++ b/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace @@ -5,7 +5,7 @@ B0($1:bool,$2:bool) CMP $6 $5 B1() B2() :void B1() CONST $7 true :bool - RETURN $7 :bool + RETURN $0 $7 :bool B2() CONST $10 false :bool - RETURN $10 :bool + RETURN $0 $10 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolNot.trace b/nautilus/test/data/bool-tests/tracing/boolNot.trace index f3b0e700..9fb62049 100644 --- a/nautilus/test/data/bool-tests/tracing/boolNot.trace +++ b/nautilus/test/data/bool-tests/tracing/boolNot.trace @@ -1,4 +1,4 @@ B0($1:bool) ASSIGN $2 $1 :bool NOT $3 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolNotEquals.trace b/nautilus/test/data/bool-tests/tracing/boolNotEquals.trace index 915cacfb..ed11df13 100644 --- a/nautilus/test/data/bool-tests/tracing/boolNotEquals.trace +++ b/nautilus/test/data/bool-tests/tracing/boolNotEquals.trace @@ -1,3 +1,3 @@ B0($1:bool,$2:bool) NEQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolOr.trace b/nautilus/test/data/bool-tests/tracing/boolOr.trace index 34eb0bc7..03926258 100644 --- a/nautilus/test/data/bool-tests/tracing/boolOr.trace +++ b/nautilus/test/data/bool-tests/tracing/boolOr.trace @@ -2,4 +2,4 @@ B0($1:bool,$2:bool) ASSIGN $3 $1 :bool ASSIGN $4 $2 :bool OR $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i16.trace index c5c7414b..8e45b721 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i32.trace index 786190c7..35b41966 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i64.trace index eaebff97..3cdf1442 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i8.trace index 29d2d7ce..fe85c7b9 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_i8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui16.trace index df91c955..8211c5f0 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui32.trace index cb2106b6..e344a7a5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui64.trace index 926054a0..d5daaa4a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui8.trace index 4477eb5d..d827924d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_d_ui8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i16.trace index bc579d7a..c9e686e4 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i32.trace index 10399631..a0956188 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i64.trace index ea2471bf..d4a81d01 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i8.trace index 95ac587d..900a7bd2 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_i8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui16.trace index 5c25a4f9..b8989292 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui32.trace index 89e188af..b3ac6c1c 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui64.trace index e4a108b0..94084c64 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui8.trace index 648cbee5..6bb09bd8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_f_ui8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i16.trace index 5c367da7..db1be859 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i16.trace @@ -1,2 +1,2 @@ B0($1:i16) - RETURN $1 :i16 + RETURN $0 $1 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i32.trace index 6fed6416..130f26a5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i64.trace index 56d913af..d7bfc6cc 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i8.trace index 83e1b2b4..4a925ff8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_i8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui16.trace index 8109e6eb..2e56ac3a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui16.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui32.trace index 9ba83981..a70b3903 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui64.trace index daf7fe5f..624b8a34 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui8.trace index 0f19d567..43d3c182 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i16_ui8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i16.trace index ddc232d2..11733fb1 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i32.trace index f4d13fba..20ad5588 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i32.trace @@ -1,2 +1,2 @@ B0($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i64.trace index 94189ec2..6b84951a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i8.trace index a153a27c..3de922bd 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_i8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui16.trace index 6ea9da5b..7e7283d6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui32.trace index b6fcccf2..7fcca883 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui32.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui64.trace index 044468d5..81a4a670 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui8.trace index 4067793b..230034f8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i32_ui8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i16.trace index bbb810fb..7ccc375d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i32.trace index 8acef449..e80e73f4 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i64.trace index e73ef494..8c1d7a99 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i64.trace @@ -1,2 +1,2 @@ B0($1:i64) - RETURN $1 :i64 + RETURN $0 $1 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i8.trace index 0a52aed1..367d4107 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_i8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui16.trace index 12a6b63a..39de77d6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui32.trace index 3687fb73..1909e858 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui64.trace index 14e282e0..d34a4de3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui64.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui8.trace index 865e6578..a78c27c5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i64_ui8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i16.trace index 8776e24f..3367fd64 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i32.trace index a30ad079..501df6e9 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i64.trace index 975e8462..10493f1f 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i8.trace index 43b9acd1..68d3e3d3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_i8.trace @@ -1,2 +1,2 @@ B0($1:i8) - RETURN $1 :i8 + RETURN $0 $1 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui16.trace index 24fc597a..04292735 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui32.trace index e8a68c1a..62144268 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui64.trace index ea8a669d..9605c1a6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui8.trace index 020bf320..1608108a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_i8_ui8.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i16.trace index b77f50b5..020f6c8d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i16.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i32.trace index 1766b961..333e6af3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i64.trace index 9710f2e9..f6486aff 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i8.trace index bc2a6de6..2c128d6b 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_i8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui16.trace index 694938c2..37666eab 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui16.trace @@ -1,2 +1,2 @@ B0($1:ui16) - RETURN $1 :ui16 + RETURN $0 $1 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui32.trace index f8feb2fa..d77730ef 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui64.trace index a22d23eb..f3dfd8c6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui8.trace index 820ec966..fea0c71a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui16_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i16.trace index 9fe4a2b3..dd8c30c3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i32.trace index 81978586..75bfa8d8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i32.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i64.trace index 964cf673..7da5a1b5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i8.trace index 61254476..836a02fc 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_i8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui16.trace index c6697b49..d809e042 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui32.trace index 436f261e..8670abdb 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui32.trace @@ -1,2 +1,2 @@ B0($1:ui32) - RETURN $1 :ui32 + RETURN $0 $1 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui64.trace index e96f4bcd..62dd312c 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui8.trace index d47acf1b..9dd2de79 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui32_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i16.trace index 1f948a47..de6d447d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i32.trace index b2ed7333..ed95d438 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i64.trace index 8259f895..4589bd25 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i64.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i8.trace index cffe51b9..b9efb014 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_i8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui16.trace index 77f55a4a..c6b25bed 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui32.trace index c141f921..dda01469 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui64.trace index 35c5acd7..f4c4847a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui64.trace @@ -1,2 +1,2 @@ B0($1:ui64) - RETURN $1 :ui64 + RETURN $0 $1 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui8.trace index 7ce4bace..8da7b2e3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui64_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i16.trace index 22ce9603..6945ad6f 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i32.trace index 2c2945c7..7bef9fce 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i64.trace index 0def4379..75dd3208 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i8.trace index 2a504194..8f10bf08 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_i8.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui16.trace index 91655b4c..89a1dfa7 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui32.trace index c3e675ef..6f88afdf 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui64.trace index 6f3da5cb..5bf3fbfb 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui8.trace index 91d89e5e..14cd09fe 100644 --- a/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/implicitCast_ui8_ui8.trace @@ -1,2 +1,2 @@ B0($1:ui8) - RETURN $1 :ui8 + RETURN $0 $1 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i16.trace index c5c7414b..8e45b721 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i32.trace index 786190c7..35b41966 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i64.trace index eaebff97..3cdf1442 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i8.trace index 29d2d7ce..fe85c7b9 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_i8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui16.trace index df91c955..8211c5f0 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui32.trace index cb2106b6..e344a7a5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui64.trace index 926054a0..d5daaa4a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui8.trace index 4477eb5d..d827924d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_d_ui8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i16.trace index bc579d7a..c9e686e4 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i32.trace index 10399631..a0956188 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i64.trace index ea2471bf..d4a81d01 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i8.trace index 95ac587d..900a7bd2 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_i8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui16.trace index 5c25a4f9..b8989292 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui32.trace index 89e188af..b3ac6c1c 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui64.trace index e4a108b0..94084c64 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui8.trace index 648cbee5..6bb09bd8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_f_ui8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i16.trace index 5c367da7..db1be859 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i16.trace @@ -1,2 +1,2 @@ B0($1:i16) - RETURN $1 :i16 + RETURN $0 $1 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i32.trace index 6fed6416..130f26a5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i64.trace index 56d913af..d7bfc6cc 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i8.trace index 83e1b2b4..4a925ff8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_i8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui16.trace index 8109e6eb..2e56ac3a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui16.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui32.trace index 9ba83981..a70b3903 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui64.trace index daf7fe5f..624b8a34 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui8.trace index 0f19d567..43d3c182 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i16_ui8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i16.trace index ddc232d2..11733fb1 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i32.trace index f4d13fba..20ad5588 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i32.trace @@ -1,2 +1,2 @@ B0($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i64.trace index 94189ec2..6b84951a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i8.trace index a153a27c..3de922bd 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_i8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui16.trace index 6ea9da5b..7e7283d6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui32.trace index b6fcccf2..7fcca883 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui32.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui64.trace index 044468d5..81a4a670 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui8.trace index 4067793b..230034f8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i32_ui8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i16.trace index bbb810fb..7ccc375d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i32.trace index 8acef449..e80e73f4 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i64.trace index e73ef494..8c1d7a99 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i64.trace @@ -1,2 +1,2 @@ B0($1:i64) - RETURN $1 :i64 + RETURN $0 $1 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i8.trace index 0a52aed1..367d4107 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_i8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui16.trace index 12a6b63a..39de77d6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui32.trace index 3687fb73..1909e858 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui64.trace index 14e282e0..d34a4de3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui64.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui8.trace index 865e6578..a78c27c5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i64_ui8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i16.trace index 8776e24f..3367fd64 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i32.trace index a30ad079..501df6e9 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i64.trace index 975e8462..10493f1f 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i8.trace index 43b9acd1..68d3e3d3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_i8.trace @@ -1,2 +1,2 @@ B0($1:i8) - RETURN $1 :i8 + RETURN $0 $1 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui16.trace index 24fc597a..04292735 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui32.trace index e8a68c1a..62144268 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui64.trace index ea8a669d..9605c1a6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui8.trace index 020bf320..1608108a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_i8_ui8.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i16.trace index b77f50b5..020f6c8d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i16.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i32.trace index 1766b961..333e6af3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i64.trace index 9710f2e9..f6486aff 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i8.trace index bc2a6de6..2c128d6b 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_i8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui16.trace index 694938c2..37666eab 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui16.trace @@ -1,2 +1,2 @@ B0($1:ui16) - RETURN $1 :ui16 + RETURN $0 $1 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui32.trace index f8feb2fa..d77730ef 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui64.trace index a22d23eb..f3dfd8c6 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui8.trace index 820ec966..fea0c71a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui16_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i16.trace index 9fe4a2b3..dd8c30c3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i32.trace index 81978586..75bfa8d8 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i32.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i64.trace index 964cf673..7da5a1b5 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i8.trace index 61254476..836a02fc 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_i8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui16.trace index c6697b49..d809e042 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui32.trace index 436f261e..8670abdb 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui32.trace @@ -1,2 +1,2 @@ B0($1:ui32) - RETURN $1 :ui32 + RETURN $0 $1 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui64.trace index e96f4bcd..62dd312c 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui8.trace index d47acf1b..9dd2de79 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui32_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i16.trace index 1f948a47..de6d447d 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i32.trace index b2ed7333..ed95d438 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i64.trace index 8259f895..4589bd25 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i64.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i8.trace index cffe51b9..b9efb014 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_i8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui16.trace index 77f55a4a..c6b25bed 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui32.trace index c141f921..dda01469 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui64.trace index 35c5acd7..f4c4847a 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui64.trace @@ -1,2 +1,2 @@ B0($1:ui64) - RETURN $1 :ui64 + RETURN $0 $1 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui8.trace index 7ce4bace..8da7b2e3 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui64_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i16.trace index 22ce9603..6945ad6f 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i32.trace index 2c2945c7..7bef9fce 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i64.trace index 0def4379..75dd3208 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i8.trace index 2a504194..8f10bf08 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_i8.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui16.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui16.trace index 91655b4c..89a1dfa7 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui16.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui32.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui32.trace index c3e675ef..6f88afdf 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui32.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui64.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui64.trace index 6f3da5cb..5bf3fbfb 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui64.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui8.trace b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui8.trace index 91d89e5e..14cd09fe 100644 --- a/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui8.trace +++ b/nautilus/test/data/cast-tests/after_ssa/staticCast_ui8_ui8.trace @@ -1,2 +1,2 @@ B0($1:ui8) - RETURN $1 :ui8 + RETURN $0 $1 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i16.trace index c5c7414b..8e45b721 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i32.trace index 786190c7..35b41966 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i64.trace index eaebff97..3cdf1442 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i8.trace index 29d2d7ce..fe85c7b9 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_i8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui16.trace index df91c955..8211c5f0 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui32.trace index cb2106b6..e344a7a5 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui64.trace index 926054a0..d5daaa4a 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui8.trace index 4477eb5d..d827924d 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_d_ui8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i16.trace index bc579d7a..c9e686e4 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i32.trace index 10399631..a0956188 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i64.trace index ea2471bf..d4a81d01 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i8.trace index 95ac587d..900a7bd2 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_i8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui16.trace index 5c25a4f9..b8989292 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui32.trace index 89e188af..b3ac6c1c 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui64.trace index e4a108b0..94084c64 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui8.trace index 648cbee5..6bb09bd8 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_f_ui8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i16.trace index a24bfd17..3dbf7efb 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i16.trace @@ -1,3 +1,3 @@ B0($1:i16) ASSIGN $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i32.trace index 6fed6416..130f26a5 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i64.trace index 56d913af..d7bfc6cc 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i8.trace index 83e1b2b4..4a925ff8 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_i8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui16.trace index 8109e6eb..2e56ac3a 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui16.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui32.trace index 9ba83981..a70b3903 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui64.trace index daf7fe5f..624b8a34 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui8.trace index 0f19d567..43d3c182 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i16_ui8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i16.trace index ddc232d2..11733fb1 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i32.trace index 7e125e8f..0555d61f 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i32.trace @@ -1,3 +1,3 @@ B0($1:i32) ASSIGN $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i64.trace index 94189ec2..6b84951a 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i8.trace index a153a27c..3de922bd 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_i8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui16.trace index 6ea9da5b..7e7283d6 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui32.trace index b6fcccf2..7fcca883 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui32.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui64.trace index 044468d5..81a4a670 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui8.trace index 4067793b..230034f8 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i32_ui8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i16.trace index bbb810fb..7ccc375d 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i32.trace index 8acef449..e80e73f4 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i64.trace index 838eb456..1487d504 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i64.trace @@ -1,3 +1,3 @@ B0($1:i64) ASSIGN $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i8.trace index 0a52aed1..367d4107 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_i8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui16.trace index 12a6b63a..39de77d6 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui32.trace index 3687fb73..1909e858 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui64.trace index 14e282e0..d34a4de3 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui64.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui8.trace index 865e6578..a78c27c5 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i64_ui8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i16.trace index 8776e24f..3367fd64 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i32.trace index a30ad079..501df6e9 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i64.trace index 975e8462..10493f1f 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i8.trace index 872b70e5..91f15786 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_i8.trace @@ -1,3 +1,3 @@ B0($1:i8) ASSIGN $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui16.trace index 24fc597a..04292735 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui32.trace index e8a68c1a..62144268 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui64.trace index ea8a669d..9605c1a6 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui8.trace index 020bf320..1608108a 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_i8_ui8.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i16.trace index b77f50b5..020f6c8d 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i16.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i32.trace index 1766b961..333e6af3 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i64.trace index 9710f2e9..f6486aff 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i8.trace index bc2a6de6..2c128d6b 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_i8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui16.trace index 0200e5df..71c90c3e 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui16) ASSIGN $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui32.trace index f8feb2fa..d77730ef 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui64.trace index a22d23eb..f3dfd8c6 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui8.trace index 820ec966..fea0c71a 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui16_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i16.trace index 9fe4a2b3..dd8c30c3 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i32.trace index 81978586..75bfa8d8 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i32.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i64.trace index 964cf673..7da5a1b5 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i8.trace index 61254476..836a02fc 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_i8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui16.trace index c6697b49..d809e042 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui32.trace index 82cbd99c..ed11f2cb 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui32) ASSIGN $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui64.trace index e96f4bcd..62dd312c 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui8.trace index d47acf1b..9dd2de79 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui32_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i16.trace index 1f948a47..de6d447d 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i32.trace index b2ed7333..ed95d438 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i64.trace index 8259f895..4589bd25 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i64.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i8.trace index cffe51b9..b9efb014 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_i8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui16.trace index 77f55a4a..c6b25bed 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui32.trace index c141f921..dda01469 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui64.trace index d2567c5c..75e226dd 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui64) ASSIGN $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui8.trace index 7ce4bace..8da7b2e3 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui64_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i16.trace index 22ce9603..6945ad6f 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i32.trace index 2c2945c7..7bef9fce 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i64.trace index 0def4379..75dd3208 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i8.trace index 2a504194..8f10bf08 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_i8.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui16.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui16.trace index 91655b4c..89a1dfa7 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui32.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui32.trace index c3e675ef..6f88afdf 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui64.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui64.trace index 6f3da5cb..5bf3fbfb 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui8.trace b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui8.trace index 0ef9c4fc..08849112 100644 --- a/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/implicitCast_ui8_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui8) ASSIGN $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_i16.trace index c5c7414b..8e45b721 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_i16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_i32.trace index 786190c7..35b41966 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_i32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_i64.trace index eaebff97..3cdf1442 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_i64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_i8.trace index 29d2d7ce..fe85c7b9 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_i8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui16.trace index df91c955..8211c5f0 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui16.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui32.trace index cb2106b6..e344a7a5 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui32.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui64.trace index 926054a0..d5daaa4a 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui64.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui8.trace index 4477eb5d..d827924d 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_d_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_d_ui8.trace @@ -1,3 +1,3 @@ B0($1:f64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_i16.trace index bc579d7a..c9e686e4 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_i16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_i32.trace index 10399631..a0956188 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_i32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_i64.trace index ea2471bf..d4a81d01 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_i64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_i8.trace index 95ac587d..900a7bd2 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_i8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui16.trace index 5c25a4f9..b8989292 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui16.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui32.trace index 89e188af..b3ac6c1c 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui32.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui64.trace index e4a108b0..94084c64 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui64.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui8.trace index 648cbee5..6bb09bd8 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_f_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_f_ui8.trace @@ -1,3 +1,3 @@ B0($1:f32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i16.trace index a24bfd17..3dbf7efb 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i16.trace @@ -1,3 +1,3 @@ B0($1:i16) ASSIGN $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i32.trace index 6fed6416..130f26a5 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i64.trace index 56d913af..d7bfc6cc 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i8.trace index 83e1b2b4..4a925ff8 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_i8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui16.trace index 8109e6eb..2e56ac3a 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui16.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui32.trace index 9ba83981..a70b3903 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui32.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui64.trace index daf7fe5f..624b8a34 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui64.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui8.trace index 0f19d567..43d3c182 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i16_ui8.trace @@ -1,3 +1,3 @@ B0($1:i16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i16.trace index ddc232d2..11733fb1 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i32.trace index 7e125e8f..0555d61f 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i32.trace @@ -1,3 +1,3 @@ B0($1:i32) ASSIGN $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i64.trace index 94189ec2..6b84951a 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i8.trace index a153a27c..3de922bd 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_i8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui16.trace index 6ea9da5b..7e7283d6 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui16.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui32.trace index b6fcccf2..7fcca883 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui32.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui64.trace index 044468d5..81a4a670 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui64.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui8.trace index 4067793b..230034f8 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i32_ui8.trace @@ -1,3 +1,3 @@ B0($1:i32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i16.trace index bbb810fb..7ccc375d 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i32.trace index 8acef449..e80e73f4 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i64.trace index 838eb456..1487d504 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i64.trace @@ -1,3 +1,3 @@ B0($1:i64) ASSIGN $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i8.trace index 0a52aed1..367d4107 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_i8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui16.trace index 12a6b63a..39de77d6 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui16.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui32.trace index 3687fb73..1909e858 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui32.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui64.trace index 14e282e0..d34a4de3 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui64.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui8.trace index 865e6578..a78c27c5 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i64_ui8.trace @@ -1,3 +1,3 @@ B0($1:i64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i16.trace index 8776e24f..3367fd64 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i32.trace index a30ad079..501df6e9 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i64.trace index 975e8462..10493f1f 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i8.trace index 872b70e5..91f15786 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_i8.trace @@ -1,3 +1,3 @@ B0($1:i8) ASSIGN $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui16.trace index 24fc597a..04292735 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui16.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui32.trace index e8a68c1a..62144268 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui32.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui64.trace index ea8a669d..9605c1a6 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui64.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui8.trace index 020bf320..1608108a 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_i8_ui8.trace @@ -1,3 +1,3 @@ B0($1:i8) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i16.trace index b77f50b5..020f6c8d 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i16.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i32.trace index 1766b961..333e6af3 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i64.trace index 9710f2e9..f6486aff 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i8.trace index bc2a6de6..2c128d6b 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_i8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui16.trace index 0200e5df..71c90c3e 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui16) ASSIGN $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui32.trace index f8feb2fa..d77730ef 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui64.trace index a22d23eb..f3dfd8c6 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui8.trace index 820ec966..fea0c71a 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui16_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui16) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i16.trace index 9fe4a2b3..dd8c30c3 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i32.trace index 81978586..75bfa8d8 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i32.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i64.trace index 964cf673..7da5a1b5 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i8.trace index 61254476..836a02fc 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_i8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui16.trace index c6697b49..d809e042 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui32.trace index 82cbd99c..ed11f2cb 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui32) ASSIGN $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui64.trace index e96f4bcd..62dd312c 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui8.trace index d47acf1b..9dd2de79 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui32_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui32) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i16.trace index 1f948a47..de6d447d 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i32.trace index b2ed7333..ed95d438 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i64.trace index 8259f895..4589bd25 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i64.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i8.trace index cffe51b9..b9efb014 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_i8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui16.trace index 77f55a4a..c6b25bed 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui32.trace index c141f921..dda01469 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui64.trace index d2567c5c..75e226dd 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui64) ASSIGN $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui8.trace index 7ce4bace..8da7b2e3 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui64_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui64) CAST $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i16.trace index 22ce9603..6945ad6f 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i16 - RETURN $2 :i16 + RETURN $0 $2 :i16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i32.trace index 2c2945c7..7bef9fce 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i64.trace index 0def4379..75dd3208 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i64 - RETURN $2 :i64 + RETURN $0 $2 :i64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i8.trace index 2a504194..8f10bf08 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_i8.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :i8 - RETURN $2 :i8 + RETURN $0 $2 :i8 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui16.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui16.trace index 91655b4c..89a1dfa7 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui16.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui16.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui16 - RETURN $2 :ui16 + RETURN $0 $2 :ui16 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui32.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui32.trace index c3e675ef..6f88afdf 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui32.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui32.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui32 - RETURN $2 :ui32 + RETURN $0 $2 :ui32 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui64.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui64.trace index 6f3da5cb..5bf3fbfb 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui64.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui64.trace @@ -1,3 +1,3 @@ B0($1:ui8) CAST $2 $1 :ui64 - RETURN $2 :ui64 + RETURN $0 $2 :ui64 diff --git a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui8.trace b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui8.trace index 0ef9c4fc..08849112 100644 --- a/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui8.trace +++ b/nautilus/test/data/cast-tests/tracing/staticCast_ui8_ui8.trace @@ -1,3 +1,3 @@ B0($1:ui8) ASSIGN $2 $1 :ui8 - RETURN $2 :ui8 + RETURN $0 $2 :ui8 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/andCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/andCondition.trace index 9c93998e..6cc00e94 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/andCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/andCondition.trace @@ -13,4 +13,4 @@ B1($3:i32) B2($3:i32) JMP $0 B3($3) :void B3($3:i32) - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace b/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace index 777f6e83..059528d0 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace @@ -12,4 +12,4 @@ B0($1:i32) CAST $15 $1 :i64 EQ $16 $15 $14 :bool AND $17 $12 $16 :bool - RETURN $17 :bool + RETURN $0 $17 :bool diff --git a/nautilus/test/data/control-flow-tests/after_ssa/complexLogicalExpressions.trace b/nautilus/test/data/control-flow-tests/after_ssa/complexLogicalExpressions.trace index f6027263..6ae3c073 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/complexLogicalExpressions.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/complexLogicalExpressions.trace @@ -18,4 +18,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/compoundAssignment.trace b/nautilus/test/data/control-flow-tests/after_ssa/compoundAssignment.trace index dd14692b..bbd84340 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/compoundAssignment.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/compoundAssignment.trace @@ -10,4 +10,4 @@ B1($2:i32) B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/compoundStatements.trace b/nautilus/test/data/control-flow-tests/after_ssa/compoundStatements.trace index adc9ed8a..3f9a758e 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/compoundStatements.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/compoundStatements.trace @@ -11,4 +11,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject.trace b/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject.trace index 24c77247..a1679844 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject.trace @@ -18,4 +18,4 @@ B2() ADD $22 $19 $21 :i32 JMP $0 B3($22) :void B3($13:i32) - RETURN $13 :i32 + RETURN $0 $13 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject2.trace b/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject2.trace index f1471ab5..6548ca71 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject2.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/constructComplexReturnObject2.trace @@ -22,4 +22,4 @@ B2() JMP $0 B3($27,$28) :void B3($3:i32,$17:i32) ControlFlowMerge ADD $18 $3 $17 :i32 - RETURN $18 :i32 + RETURN $0 $18 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseCondition.trace index 63614521..c8c12336 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseCondition.trace @@ -44,4 +44,4 @@ B11($1:i32,$10:i32) ControlFlowMerge JMP $0 B12($1,$10) :void B12($1:i32,$10:i32) ControlFlowMerge ADD $11 $1 $10 :i32 - RETURN $11 :i32 + RETURN $0 $11 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseIfCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseIfCondition.trace index 2a03b4d3..0e67b52f 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/deeplyNestedIfElseIfCondition.trace @@ -35,4 +35,4 @@ B8($1:i32,$7:i32) ControlFlowMerge JMP $0 B9($1,$7) :void B9($1:i32,$7:i32) ControlFlowMerge ADD $8 $1 $7 :i32 - RETURN $8 :i32 + RETURN $0 $8 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/doubleIfCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/doubleIfCondition.trace index e475beab..8273b12a 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/doubleIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/doubleIfCondition.trace @@ -22,4 +22,4 @@ B5($1:i32,$5:i32) ControlFlowMerge CMP $7 $6 B3($1) B4($1) :void B6($1:i32,$10:i32) ControlFlowMerge ADD $11 $1 $10 :i32 - RETURN $11 :i32 + RETURN $0 $11 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfCondition.trace index 9ad21aa1..8e793902 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfCondition.trace @@ -24,4 +24,4 @@ B5($1:i32,$7:i32) ControlFlowMerge JMP $0 B6($1,$7) :void B6($1:i32,$7:i32) ControlFlowMerge ADD $8 $1 $7 :i32 - RETURN $8 :i32 + RETURN $0 $8 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfElse.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfElse.trace index d9b17719..9f71f844 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfElse.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfElse.trace @@ -17,4 +17,4 @@ B4() CONST $13 30 :i32 JMP $0 B5($13) :void B5($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfOnly.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfOnly.trace index 4277c54d..bae97081 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfOnly.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifElseIfOnly.trace @@ -16,4 +16,4 @@ B3() B4($2:i32) JMP $0 B5($2) :void B5($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifNotEqual.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifNotEqual.trace index 4a586b43..63255672 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifNotEqual.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifNotEqual.trace @@ -9,4 +9,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifThenCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifThenCondition.trace index be2a5bbb..210ba6c3 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifThenCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifThenCondition.trace @@ -13,4 +13,4 @@ B2($2:i32) JMP $0 B3($2,$11) :void B3($2:i32,$8:i32) ControlFlowMerge ADD $9 $2 $8 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifThenElseCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifThenElseCondition.trace index 9aced513..a7daf194 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifThenElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifThenElseCondition.trace @@ -15,4 +15,4 @@ B2($2:i32) JMP $0 B3($12,$13) :void B3($2:i32,$8:i32) ControlFlowMerge ADD $9 $2 $8 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifWithFunctionCall.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifWithFunctionCall.trace index 23998b97..1fddac62 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifWithFunctionCall.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifWithFunctionCall.trace @@ -11,4 +11,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/ifWithTernary.trace b/nautilus/test/data/control-flow-tests/after_ssa/ifWithTernary.trace index 64f63066..c8bd8f66 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/ifWithTernary.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/ifWithTernary.trace @@ -19,4 +19,4 @@ B5($1:i32,$6:i32,$5:i32) ControlFlowMerge EQ $7 $1 $6 :bool CMP $8 $7 B3() B4($5) :void B6($5:i32) - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/logicalAnd.trace b/nautilus/test/data/control-flow-tests/after_ssa/logicalAnd.trace index 2ea78cc3..dd26b855 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/logicalAnd.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/logicalAnd.trace @@ -12,4 +12,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/logicalOr.trace b/nautilus/test/data/control-flow-tests/after_ssa/logicalOr.trace index 034e816f..fc83f868 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/logicalOr.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/logicalOr.trace @@ -12,4 +12,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/logicalXOR.trace b/nautilus/test/data/control-flow-tests/after_ssa/logicalXOR.trace index 694c6c25..58718bbd 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/logicalXOR.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/logicalXOR.trace @@ -12,4 +12,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/multipleConditions.trace b/nautilus/test/data/control-flow-tests/after_ssa/multipleConditions.trace index a13f9c77..daedb314 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/multipleConditions.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/multipleConditions.trace @@ -15,4 +15,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/multipleElse.trace b/nautilus/test/data/control-flow-tests/after_ssa/multipleElse.trace index 33bb17c5..6406fad6 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/multipleElse.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/multipleElse.trace @@ -18,4 +18,4 @@ B4() CONST $14 4 :i32 JMP $0 B5($14) :void B5($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/multipleVoidReturnsFunction.trace b/nautilus/test/data/control-flow-tests/after_ssa/multipleVoidReturnsFunction.trace index caee60e0..1d9a7eb9 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/multipleVoidReturnsFunction.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/multipleVoidReturnsFunction.trace @@ -5,11 +5,11 @@ B0($1:ptr) CMP $7 $6 B1($1) B2($1) :void B1($1:ptr) CONST $10 1 :i32 - STORE $1 $10 :i32 + STORE $11 $1 $10 :void JMP $0 B3() :void B2($1:ptr) - CONST $14 42 :i32 - STORE $1 $14 :i32 + CONST $15 42 :i32 + STORE $16 $1 $15 :void JMP $0 B3() :void B3() RETURN $0 :void diff --git a/nautilus/test/data/control-flow-tests/after_ssa/nestedIf.trace b/nautilus/test/data/control-flow-tests/after_ssa/nestedIf.trace index f57c4ab9..732258b7 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/nestedIf.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/nestedIf.trace @@ -16,4 +16,4 @@ B4() CONST $12 3 :i32 JMP $0 B5($12) :void B5($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfElseDifferentLevels.trace b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfElseDifferentLevels.trace index 7ec3964f..783697ec 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfElseDifferentLevels.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfElseDifferentLevels.trace @@ -24,4 +24,4 @@ B5() B6($2:i32) JMP $0 B7($2) :void B7($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfNoElseCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfNoElseCondition.trace index 14a7cd09..07c74421 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfNoElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfNoElseCondition.trace @@ -25,4 +25,4 @@ B5($2:i32,$8:i32) ControlFlowMerge JMP $0 B6($2,$8) :void B6($2:i32,$8:i32) ControlFlowMerge ADD $9 $2 $8 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfThenElseCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfThenElseCondition.trace index 6f5cf778..50ef9013 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/nestedIfThenElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/nestedIfThenElseCondition.trace @@ -21,4 +21,4 @@ B5($2:i32,$6:i32) ControlFlowMerge JMP $0 B6($2,$6) :void B6($2:i32,$6:i32) ControlFlowMerge ADD $7 $2 $6 :i32 - RETURN $7 :i32 + RETURN $0 $7 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/orCondition.trace b/nautilus/test/data/control-flow-tests/after_ssa/orCondition.trace index 7d5f2c24..4d2a1991 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/orCondition.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/orCondition.trace @@ -13,4 +13,4 @@ B1($2:i32) B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/shortCircuitEvaluation.trace b/nautilus/test/data/control-flow-tests/after_ssa/shortCircuitEvaluation.trace index 05dc85ff..ee368366 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/shortCircuitEvaluation.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/shortCircuitEvaluation.trace @@ -14,4 +14,4 @@ B1() B2($2:i32) JMP $0 B3($2) :void B3($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/varyingComplexity.trace b/nautilus/test/data/control-flow-tests/after_ssa/varyingComplexity.trace index 6955251f..f0527d4e 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/varyingComplexity.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/varyingComplexity.trace @@ -28,4 +28,4 @@ B5($2:i32) B6($2:i32) JMP $0 B7($2) :void B7($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/ir/multipleVoidReturnsFunction.trace b/nautilus/test/data/control-flow-tests/ir/multipleVoidReturnsFunction.trace index 6bf8551d..47a2d69a 100644 --- a/nautilus/test/data/control-flow-tests/ir/multipleVoidReturnsFunction.trace +++ b/nautilus/test/data/control-flow-tests/ir/multipleVoidReturnsFunction.trace @@ -15,8 +15,8 @@ Block_3(): return :void Block_2($1:ptr): - $14 = 42 :i32 - store($14, $1) :void + $15 = 42 :i32 + store($15, $1) :void br Block_3() :void } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/control-flow-tests/tracing/andCondition.trace b/nautilus/test/data/control-flow-tests/tracing/andCondition.trace index 3ce5204d..bc96e42e 100644 --- a/nautilus/test/data/control-flow-tests/tracing/andCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/andCondition.trace @@ -10,6 +10,6 @@ B1() CONST $10 14 :i32 ADD $11 $3 $10 :i32 ASSIGN $3 $11 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 B2() - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/andFunction.trace b/nautilus/test/data/control-flow-tests/tracing/andFunction.trace index 30f76c26..9a82b42f 100644 --- a/nautilus/test/data/control-flow-tests/tracing/andFunction.trace +++ b/nautilus/test/data/control-flow-tests/tracing/andFunction.trace @@ -18,4 +18,4 @@ B0($1:i32) EQ $16 $15 $14 :bool AND $17 $13 $16 :bool ASSIGN $2 $17 :bool - RETURN $2 :bool + RETURN $0 $2 :bool diff --git a/nautilus/test/data/control-flow-tests/tracing/complexLogicalExpressions.trace b/nautilus/test/data/control-flow-tests/tracing/complexLogicalExpressions.trace index 9e97cd79..e10517a6 100644 --- a/nautilus/test/data/control-flow-tests/tracing/complexLogicalExpressions.trace +++ b/nautilus/test/data/control-flow-tests/tracing/complexLogicalExpressions.trace @@ -15,6 +15,6 @@ B0($1:i32) B1() CONST $15 1 :i32 ASSIGN $2 $15 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/compoundAssignment.trace b/nautilus/test/data/control-flow-tests/tracing/compoundAssignment.trace index 64c29b0f..bb65722c 100644 --- a/nautilus/test/data/control-flow-tests/tracing/compoundAssignment.trace +++ b/nautilus/test/data/control-flow-tests/tracing/compoundAssignment.trace @@ -7,6 +7,6 @@ B1() CONST $6 5 :i32 ADD $7 $2 $6 :i32 ASSIGN $2 $7 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/compoundStatements.trace b/nautilus/test/data/control-flow-tests/tracing/compoundStatements.trace index 7b4cec53..449630de 100644 --- a/nautilus/test/data/control-flow-tests/tracing/compoundStatements.trace +++ b/nautilus/test/data/control-flow-tests/tracing/compoundStatements.trace @@ -9,6 +9,6 @@ B1() CONST $7 2 :i32 MUL $8 $2 $7 :i32 ASSIGN $2 $8 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject.trace b/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject.trace index e640c42e..018928d8 100644 --- a/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject.trace +++ b/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject.trace @@ -11,7 +11,7 @@ B1() CONST $11 1 :i32 ADD $12 $8 $11 :i32 ADD $13 $10 $12 :i32 - RETURN $13 :i32 + RETURN $0 $13 :i32 B2() CONST $16 0 :i32 CONST $17 0 :i32 @@ -20,4 +20,4 @@ B2() CONST $20 1 :i32 ADD $21 $17 $20 :i32 ADD $22 $19 $21 :i32 - RETURN $22 :i32 + RETURN $0 $22 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject2.trace b/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject2.trace index 80adcf12..a91adfc6 100644 --- a/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject2.trace +++ b/nautilus/test/data/control-flow-tests/tracing/constructComplexReturnObject2.trace @@ -31,4 +31,4 @@ B2() JMP $0 B3() :void B3() ControlFlowMerge ADD $18 $3 $17 :i32 - RETURN $18 :i32 + RETURN $0 $18 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseCondition.trace b/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseCondition.trace index 6a028597..ae3df982 100644 --- a/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseCondition.trace @@ -53,4 +53,4 @@ B12() ControlFlowMerge ADD $11 $1 $10 :i32 ASSIGN $1 $11 :i32 ASSIGN $12 $1 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseIfCondition.trace b/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseIfCondition.trace index fbe3c004..b552b6c5 100644 --- a/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/deeplyNestedIfElseIfCondition.trace @@ -43,4 +43,4 @@ B9() ControlFlowMerge ADD $8 $1 $7 :i32 ASSIGN $1 $8 :i32 ASSIGN $9 $1 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/doubleIfCondition.trace b/nautilus/test/data/control-flow-tests/tracing/doubleIfCondition.trace index 1fd31586..a1fc762c 100644 --- a/nautilus/test/data/control-flow-tests/tracing/doubleIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/doubleIfCondition.trace @@ -27,4 +27,4 @@ B6() ControlFlowMerge ADD $11 $1 $10 :i32 ASSIGN $1 $11 :i32 ASSIGN $12 $1 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifElseIfCondition.trace b/nautilus/test/data/control-flow-tests/tracing/ifElseIfCondition.trace index 4bc5319d..8fb9fb32 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifElseIfCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifElseIfCondition.trace @@ -30,4 +30,4 @@ B6() ControlFlowMerge ADD $8 $1 $7 :i32 ASSIGN $1 $8 :i32 ASSIGN $9 $1 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifElseIfElse.trace b/nautilus/test/data/control-flow-tests/tracing/ifElseIfElse.trace index d4e3513e..717bf515 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifElseIfElse.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifElseIfElse.trace @@ -6,7 +6,7 @@ B0($1:i32) B1() CONST $6 10 :i32 ASSIGN $2 $6 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() CONST $8 1 :i32 EQ $9 $1 $8 :bool @@ -14,8 +14,8 @@ B2() B3() CONST $11 20 :i32 ASSIGN $2 $11 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B4() CONST $13 30 :i32 ASSIGN $2 $13 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifElseIfOnly.trace b/nautilus/test/data/control-flow-tests/tracing/ifElseIfOnly.trace index 4332a689..515d7504 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifElseIfOnly.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifElseIfOnly.trace @@ -6,7 +6,7 @@ B0($1:i32) B1() CONST $6 1 :i32 ASSIGN $2 $6 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() CONST $8 10 :i32 LT $9 $1 $8 :bool @@ -14,6 +14,6 @@ B2() B3() CONST $11 2 :i32 ASSIGN $2 $11 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B4() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifNotEqual.trace b/nautilus/test/data/control-flow-tests/tracing/ifNotEqual.trace index 6c128770..8baa5f62 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifNotEqual.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifNotEqual.trace @@ -6,6 +6,6 @@ B0($1:i32) B1() CONST $6 2 :i32 ASSIGN $2 $6 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifThenCondition.trace b/nautilus/test/data/control-flow-tests/tracing/ifThenCondition.trace index e569c384..62ad7d9c 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifThenCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifThenCondition.trace @@ -15,4 +15,4 @@ B2() JMP $0 B3() :void B3() ControlFlowMerge ADD $9 $2 $8 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifThenElseCondition.trace b/nautilus/test/data/control-flow-tests/tracing/ifThenElseCondition.trace index b86cf99f..24d9edac 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifThenElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifThenElseCondition.trace @@ -18,4 +18,4 @@ B2() JMP $0 B3() :void B3() ControlFlowMerge ADD $9 $2 $8 :i32 - RETURN $9 :i32 + RETURN $0 $9 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifWithFunctionCall.trace b/nautilus/test/data/control-flow-tests/tracing/ifWithFunctionCall.trace index cf14f318..e722db61 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifWithFunctionCall.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifWithFunctionCall.trace @@ -9,6 +9,6 @@ B0($1:i32) B1() CONST $9 1 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/ifWithTernary.trace b/nautilus/test/data/control-flow-tests/tracing/ifWithTernary.trace index 51e9554d..3734c78b 100644 --- a/nautilus/test/data/control-flow-tests/tracing/ifWithTernary.trace +++ b/nautilus/test/data/control-flow-tests/tracing/ifWithTernary.trace @@ -15,9 +15,9 @@ B2() B3() CONST $9 -1 :i32 ASSIGN $5 $9 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 B4() - RETURN $5 :i32 + RETURN $0 $5 :i32 B5() ControlFlowMerge EQ $7 $1 $6 :bool CMP $8 $7 B3() B4() :void diff --git a/nautilus/test/data/control-flow-tests/tracing/logicalAnd.trace b/nautilus/test/data/control-flow-tests/tracing/logicalAnd.trace index cc61f945..22c526cd 100644 --- a/nautilus/test/data/control-flow-tests/tracing/logicalAnd.trace +++ b/nautilus/test/data/control-flow-tests/tracing/logicalAnd.trace @@ -9,6 +9,6 @@ B0($1:i32) B1() CONST $9 1 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/logicalOr.trace b/nautilus/test/data/control-flow-tests/tracing/logicalOr.trace index e8eae1cf..d92feb72 100644 --- a/nautilus/test/data/control-flow-tests/tracing/logicalOr.trace +++ b/nautilus/test/data/control-flow-tests/tracing/logicalOr.trace @@ -9,6 +9,6 @@ B0($1:i32) B1() CONST $9 1 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/logicalXOR.trace b/nautilus/test/data/control-flow-tests/tracing/logicalXOR.trace index f69fe48f..db7c8b82 100644 --- a/nautilus/test/data/control-flow-tests/tracing/logicalXOR.trace +++ b/nautilus/test/data/control-flow-tests/tracing/logicalXOR.trace @@ -9,6 +9,6 @@ B0($1:i32) B1() CONST $9 1 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/multipleConditions.trace b/nautilus/test/data/control-flow-tests/tracing/multipleConditions.trace index 79a8b5dd..102a1bc5 100644 --- a/nautilus/test/data/control-flow-tests/tracing/multipleConditions.trace +++ b/nautilus/test/data/control-flow-tests/tracing/multipleConditions.trace @@ -12,6 +12,6 @@ B0($1:i32) B1() CONST $12 1 :i32 ASSIGN $2 $12 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/multipleElse.trace b/nautilus/test/data/control-flow-tests/tracing/multipleElse.trace index 29c7359a..55b230d8 100644 --- a/nautilus/test/data/control-flow-tests/tracing/multipleElse.trace +++ b/nautilus/test/data/control-flow-tests/tracing/multipleElse.trace @@ -6,7 +6,7 @@ B0($1:i32) B1() CONST $6 1 :i32 ASSIGN $2 $6 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() CONST $8 2 :i32 ASSIGN $2 $8 :i32 @@ -16,8 +16,8 @@ B2() B3() CONST $12 3 :i32 ASSIGN $2 $12 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B4() CONST $14 4 :i32 ASSIGN $2 $14 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/multipleVoidReturnsFunction.trace b/nautilus/test/data/control-flow-tests/tracing/multipleVoidReturnsFunction.trace index 772aae05..738d0b26 100644 --- a/nautilus/test/data/control-flow-tests/tracing/multipleVoidReturnsFunction.trace +++ b/nautilus/test/data/control-flow-tests/tracing/multipleVoidReturnsFunction.trace @@ -9,11 +9,11 @@ B1() ASSIGN $8 $1 :ptr ASSIGN $9 $8 :ptr CONST $10 1 :i32 - STORE $1 $10 :i32 + STORE $11 $1 $10 :void RETURN $0 :void B2() - ASSIGN $12 $1 :ptr - ASSIGN $13 $12 :ptr - CONST $14 42 :i32 - STORE $1 $14 :i32 + ASSIGN $13 $1 :ptr + ASSIGN $14 $13 :ptr + CONST $15 42 :i32 + STORE $16 $1 $15 :void RETURN $0 :void diff --git a/nautilus/test/data/control-flow-tests/tracing/nestedIf.trace b/nautilus/test/data/control-flow-tests/tracing/nestedIf.trace index dffeb11e..f3b28d3f 100644 --- a/nautilus/test/data/control-flow-tests/tracing/nestedIf.trace +++ b/nautilus/test/data/control-flow-tests/tracing/nestedIf.trace @@ -8,12 +8,12 @@ B1() GT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() CONST $9 2 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B4() CONST $12 3 :i32 ASSIGN $2 $12 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/nestedIfElseDifferentLevels.trace b/nautilus/test/data/control-flow-tests/tracing/nestedIfElseDifferentLevels.trace index 4a3d6bef..01c61d23 100644 --- a/nautilus/test/data/control-flow-tests/tracing/nestedIfElseDifferentLevels.trace +++ b/nautilus/test/data/control-flow-tests/tracing/nestedIfElseDifferentLevels.trace @@ -10,11 +10,11 @@ B1() B2() CONST $11 -1 :i32 ASSIGN $2 $11 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() CONST $9 1 :i32 ASSIGN $2 $9 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B4() CONST $13 2 :i32 ASSIGN $2 $13 :i32 @@ -24,6 +24,6 @@ B4() B5() CONST $17 3 :i32 ASSIGN $2 $17 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B6() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/nestedIfNoElseCondition.trace b/nautilus/test/data/control-flow-tests/tracing/nestedIfNoElseCondition.trace index c35710c2..f0d095da 100644 --- a/nautilus/test/data/control-flow-tests/tracing/nestedIfNoElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/nestedIfNoElseCondition.trace @@ -31,4 +31,4 @@ B6() ControlFlowMerge ADD $9 $2 $8 :i32 ASSIGN $2 $9 :i32 ASSIGN $10 $2 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/nestedIfThenElseCondition.trace b/nautilus/test/data/control-flow-tests/tracing/nestedIfThenElseCondition.trace index 6d68c4b2..ca79fa74 100644 --- a/nautilus/test/data/control-flow-tests/tracing/nestedIfThenElseCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/nestedIfThenElseCondition.trace @@ -26,4 +26,4 @@ B6() ControlFlowMerge ADD $7 $2 $6 :i32 ASSIGN $2 $7 :i32 ASSIGN $8 $2 :i32 - RETURN $8 :i32 + RETURN $0 $8 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/orCondition.trace b/nautilus/test/data/control-flow-tests/tracing/orCondition.trace index 93ee667f..18712bbe 100644 --- a/nautilus/test/data/control-flow-tests/tracing/orCondition.trace +++ b/nautilus/test/data/control-flow-tests/tracing/orCondition.trace @@ -10,6 +10,6 @@ B1() CONST $9 14 :i32 ADD $10 $2 $9 :i32 ASSIGN $2 $10 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/shortCircuitEvaluation.trace b/nautilus/test/data/control-flow-tests/tracing/shortCircuitEvaluation.trace index a493b98c..f75e8288 100644 --- a/nautilus/test/data/control-flow-tests/tracing/shortCircuitEvaluation.trace +++ b/nautilus/test/data/control-flow-tests/tracing/shortCircuitEvaluation.trace @@ -11,6 +11,6 @@ B0($1:i32) B1() CONST $11 1 :i32 ASSIGN $2 $11 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/varyingComplexity.trace b/nautilus/test/data/control-flow-tests/tracing/varyingComplexity.trace index c36219d1..e2900fa2 100644 --- a/nautilus/test/data/control-flow-tests/tracing/varyingComplexity.trace +++ b/nautilus/test/data/control-flow-tests/tracing/varyingComplexity.trace @@ -6,7 +6,7 @@ B0($1:i32) B1() CONST $6 1 :i32 ASSIGN $2 $6 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B2() CONST $8 5 :i32 GTE $9 $1 $8 :bool @@ -23,11 +23,11 @@ B3() B4() CONST $21 3 :i32 ASSIGN $2 $21 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B5() CONST $18 1 :i32 ADD $19 $2 $18 :i32 ASSIGN $2 $19 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B6() - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/enum-tests/after_ssa/callEnumClassFunction.trace b/nautilus/test/data/enum-tests/after_ssa/callEnumClassFunction.trace index f18f79c8..2155feb1 100644 --- a/nautilus/test/data/enum-tests/after_ssa/callEnumClassFunction.trace +++ b/nautilus/test/data/enum-tests/after_ssa/callEnumClassFunction.trace @@ -1,3 +1,3 @@ B0($1:ui8) - CALL $2 nautilus::enumClassFunction(nautilus::LogLevel)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZN8nautilus17enumClassFunctionENS_8LogLevelE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/enum-tests/after_ssa/callEnumFunction.trace b/nautilus/test/data/enum-tests/after_ssa/callEnumFunction.trace index 584e7ea8..6593a7fc 100644 --- a/nautilus/test/data/enum-tests/after_ssa/callEnumFunction.trace +++ b/nautilus/test/data/enum-tests/after_ssa/callEnumFunction.trace @@ -1,3 +1,3 @@ B0($1:ui32) - CALL $2 nautilus::enumFunction(nautilus::Color)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZN8nautilus12enumFunctionENS_5ColorE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/enum-tests/after_ssa/getEnum.trace b/nautilus/test/data/enum-tests/after_ssa/getEnum.trace index c6d74556..55640f4e 100644 --- a/nautilus/test/data/enum-tests/after_ssa/getEnum.trace +++ b/nautilus/test/data/enum-tests/after_ssa/getEnum.trace @@ -1,3 +1,3 @@ B0() CONST $1 0 :ui32 - RETURN $1 :ui32 + RETURN $0 $1 :ui32 diff --git a/nautilus/test/data/enum-tests/after_ssa/handleEnum.trace b/nautilus/test/data/enum-tests/after_ssa/handleEnum.trace index cdf4dd64..c2615358 100644 --- a/nautilus/test/data/enum-tests/after_ssa/handleEnum.trace +++ b/nautilus/test/data/enum-tests/after_ssa/handleEnum.trace @@ -1,4 +1,4 @@ B0($1:ui32) CONST $2 0 :ui32 EQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/enum-tests/after_ssa/handleEnumLogLevel.trace b/nautilus/test/data/enum-tests/after_ssa/handleEnumLogLevel.trace index 589d6239..9ad89b01 100644 --- a/nautilus/test/data/enum-tests/after_ssa/handleEnumLogLevel.trace +++ b/nautilus/test/data/enum-tests/after_ssa/handleEnumLogLevel.trace @@ -4,4 +4,4 @@ B0($1:ui8) CONST $4 5 :ui8 EQ $5 $1 $4 :bool OR $6 $3 $5 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/enum-tests/after_ssa/isEnum.trace b/nautilus/test/data/enum-tests/after_ssa/isEnum.trace index adc272c5..cadc1d73 100644 --- a/nautilus/test/data/enum-tests/after_ssa/isEnum.trace +++ b/nautilus/test/data/enum-tests/after_ssa/isEnum.trace @@ -16,4 +16,4 @@ B4() CONST $12 42 :i32 JMP $0 B5($12) :void B5($5:i32) - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/enum-tests/ir/callEnumClassFunction.trace b/nautilus/test/data/enum-tests/ir/callEnumClassFunction.trace index bdb02ba7..7d03e8f4 100644 --- a/nautilus/test/data/enum-tests/ir/callEnumClassFunction.trace +++ b/nautilus/test/data/enum-tests/ir/callEnumClassFunction.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:ui8): - $2 = nautilus::enumClassFunction(nautilus::LogLevel)($1) :i32 + $2 = _ZN8nautilus17enumClassFunctionENS_8LogLevelE($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/enum-tests/ir/callEnumFunction.trace b/nautilus/test/data/enum-tests/ir/callEnumFunction.trace index e093ded3..567692b1 100644 --- a/nautilus/test/data/enum-tests/ir/callEnumFunction.trace +++ b/nautilus/test/data/enum-tests/ir/callEnumFunction.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:ui32): - $2 = nautilus::enumFunction(nautilus::Color)($1) :i32 + $2 = _ZN8nautilus12enumFunctionENS_5ColorE($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/enum-tests/tracing/callEnumClassFunction.trace b/nautilus/test/data/enum-tests/tracing/callEnumClassFunction.trace index f18f79c8..2155feb1 100644 --- a/nautilus/test/data/enum-tests/tracing/callEnumClassFunction.trace +++ b/nautilus/test/data/enum-tests/tracing/callEnumClassFunction.trace @@ -1,3 +1,3 @@ B0($1:ui8) - CALL $2 nautilus::enumClassFunction(nautilus::LogLevel)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZN8nautilus17enumClassFunctionENS_8LogLevelE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/enum-tests/tracing/callEnumFunction.trace b/nautilus/test/data/enum-tests/tracing/callEnumFunction.trace index 584e7ea8..6593a7fc 100644 --- a/nautilus/test/data/enum-tests/tracing/callEnumFunction.trace +++ b/nautilus/test/data/enum-tests/tracing/callEnumFunction.trace @@ -1,3 +1,3 @@ B0($1:ui32) - CALL $2 nautilus::enumFunction(nautilus::Color)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZN8nautilus12enumFunctionENS_5ColorE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/enum-tests/tracing/getEnum.trace b/nautilus/test/data/enum-tests/tracing/getEnum.trace index c6d74556..55640f4e 100644 --- a/nautilus/test/data/enum-tests/tracing/getEnum.trace +++ b/nautilus/test/data/enum-tests/tracing/getEnum.trace @@ -1,3 +1,3 @@ B0() CONST $1 0 :ui32 - RETURN $1 :ui32 + RETURN $0 $1 :ui32 diff --git a/nautilus/test/data/enum-tests/tracing/handleEnum.trace b/nautilus/test/data/enum-tests/tracing/handleEnum.trace index cdf4dd64..c2615358 100644 --- a/nautilus/test/data/enum-tests/tracing/handleEnum.trace +++ b/nautilus/test/data/enum-tests/tracing/handleEnum.trace @@ -1,4 +1,4 @@ B0($1:ui32) CONST $2 0 :ui32 EQ $3 $1 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/enum-tests/tracing/handleEnumLogLevel.trace b/nautilus/test/data/enum-tests/tracing/handleEnumLogLevel.trace index 589d6239..9ad89b01 100644 --- a/nautilus/test/data/enum-tests/tracing/handleEnumLogLevel.trace +++ b/nautilus/test/data/enum-tests/tracing/handleEnumLogLevel.trace @@ -4,4 +4,4 @@ B0($1:ui8) CONST $4 5 :ui8 EQ $5 $1 $4 :bool OR $6 $3 $5 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/enum-tests/tracing/isEnum.trace b/nautilus/test/data/enum-tests/tracing/isEnum.trace index 3f4ff1ad..1df235b2 100644 --- a/nautilus/test/data/enum-tests/tracing/isEnum.trace +++ b/nautilus/test/data/enum-tests/tracing/isEnum.trace @@ -4,14 +4,14 @@ B0($1:ui32) CMP $4 $3 B1() B2() :void B1() CONST $5 1 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 B2() CONST $7 1 :ui32 EQ $8 $1 $7 :bool CMP $9 $8 B3() B4() :void B3() CONST $10 2 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 B4() CONST $12 42 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignAdd.trace b/nautilus/test/data/expression-tests/after_ssa/assignAdd.trace index 3a79fe61..7f523998 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignAdd.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignAdd.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 ADD $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignAnd.trace b/nautilus/test/data/expression-tests/after_ssa/assignAnd.trace index 3cc24dee..faf6f7cc 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignAnd.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignAnd.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 BAND $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignDiv.trace b/nautilus/test/data/expression-tests/after_ssa/assignDiv.trace index a0295e0a..78ff34ad 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignDiv.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignDiv.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 DIV $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignMod.trace b/nautilus/test/data/expression-tests/after_ssa/assignMod.trace index 5b232e01..a50442c9 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignMod.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignMod.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 MOD $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignMul.trace b/nautilus/test/data/expression-tests/after_ssa/assignMul.trace index dfceeaf8..c1fcd877 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignMul.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignMul.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 MUL $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignOr.trace b/nautilus/test/data/expression-tests/after_ssa/assignOr.trace index fdf01ca0..4e227c0d 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignOr.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignOr.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 BOR $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignShl.trace b/nautilus/test/data/expression-tests/after_ssa/assignShl.trace index 9ad18711..a32e1126 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignShl.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignShl.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 LSH $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignShr.trace b/nautilus/test/data/expression-tests/after_ssa/assignShr.trace index 73a8ff80..e9fcfc29 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignShr.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignShr.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 RSH $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignSub.trace b/nautilus/test/data/expression-tests/after_ssa/assignSub.trace index b71b008e..0ef35f2e 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignSub.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignSub.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 SUB $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignXor.trace b/nautilus/test/data/expression-tests/after_ssa/assignXor.trace index 65d4e839..e7b6287c 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignXor.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignXor.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 BXOR $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignment1.trace b/nautilus/test/data/expression-tests/after_ssa/assignment1.trace index f4d13fba..20ad5588 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignment1.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignment1.trace @@ -1,2 +1,2 @@ B0($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignment2.trace b/nautilus/test/data/expression-tests/after_ssa/assignment2.trace index 362c761d..1960e2a6 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignment2.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignment2.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $1 $3 :i32 - RETURN $4 :i32 + RETURN $0 $4 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignment3.trace b/nautilus/test/data/expression-tests/after_ssa/assignment3.trace index a2ceaaf2..0aae1a0f 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignment3.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignment3.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignment4.trace b/nautilus/test/data/expression-tests/after_ssa/assignment4.trace index 3f481100..e4af0814 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignment4.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignment4.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 42 :i32 CONST $3 1 :i32 ADD $4 $1 $3 :i32 - RETURN $4 :i32 + RETURN $0 $4 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/assignment5.trace b/nautilus/test/data/expression-tests/after_ssa/assignment5.trace index f6a141b9..148883a2 100644 --- a/nautilus/test/data/expression-tests/after_ssa/assignment5.trace +++ b/nautilus/test/data/expression-tests/after_ssa/assignment5.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 42 :i32 CONST $3 1 :i32 ADD $4 $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/castFloatToDoubleAddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/castFloatToDoubleAddExpression.trace index b3d5aef5..2acf8a2a 100644 --- a/nautilus/test/data/expression-tests/after_ssa/castFloatToDoubleAddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/castFloatToDoubleAddExpression.trace @@ -2,4 +2,4 @@ B0($1:f32) CONST $2 7 :f64 CAST $3 $1 :f64 ADD $4 $3 $2 :f64 - RETURN $4 :f64 + RETURN $0 $4 :f64 diff --git a/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression.trace index 30d667b2..fe034cfb 100644 --- a/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression.trace @@ -2,4 +2,4 @@ B0($1:i8) CONST $2 7 :i64 CAST $3 $1 :i64 ADD $4 $3 $2 :i64 - RETURN $4 :i64 + RETURN $0 $4 :i64 diff --git a/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression2.trace b/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression2.trace index 313c3fc0..02e4ce0d 100644 --- a/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression2.trace +++ b/nautilus/test/data/expression-tests/after_ssa/castInt8ToInt64AddExpression2.trace @@ -2,4 +2,4 @@ B0($1:i8) CONST $2 42 :i64 CAST $3 $1 :i64 ADD $4 $2 $3 :i64 - RETURN $4 :i64 + RETURN $0 $4 :i64 diff --git a/nautilus/test/data/expression-tests/after_ssa/decrementPost.trace b/nautilus/test/data/expression-tests/after_ssa/decrementPost.trace index e7e3b009..bd06b480 100644 --- a/nautilus/test/data/expression-tests/after_ssa/decrementPost.trace +++ b/nautilus/test/data/expression-tests/after_ssa/decrementPost.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $3 1 :i32 SUB $4 $1 $3 :i32 ADD $5 $1 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/decrementPre.trace b/nautilus/test/data/expression-tests/after_ssa/decrementPre.trace index f4bb372c..534c57c2 100644 --- a/nautilus/test/data/expression-tests/after_ssa/decrementPre.trace +++ b/nautilus/test/data/expression-tests/after_ssa/decrementPre.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 1 :i32 SUB $3 $1 $2 :i32 ADD $5 $3 $3 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/doubleAddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/doubleAddExpression.trace index b7b9549d..e86029f0 100644 --- a/nautilus/test/data/expression-tests/after_ssa/doubleAddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/doubleAddExpression.trace @@ -1,4 +1,4 @@ B0($1:f64) CONST $2 7 :f64 ADD $3 $1 $2 :f64 - RETURN $3 :f64 + RETURN $0 $3 :f64 diff --git a/nautilus/test/data/expression-tests/after_ssa/floatAddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/floatAddExpression.trace index 055d89bf..6081486e 100644 --- a/nautilus/test/data/expression-tests/after_ssa/floatAddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/floatAddExpression.trace @@ -1,4 +1,4 @@ B0($1:f32) CONST $2 7 :f32 ADD $3 $1 $2 :f32 - RETURN $3 :f32 + RETURN $0 $3 :f32 diff --git a/nautilus/test/data/expression-tests/after_ssa/incrementPost.trace b/nautilus/test/data/expression-tests/after_ssa/incrementPost.trace index beb8623a..b5c2348d 100644 --- a/nautilus/test/data/expression-tests/after_ssa/incrementPost.trace +++ b/nautilus/test/data/expression-tests/after_ssa/incrementPost.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $1 $3 :i32 ADD $5 $1 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/incrementPre.trace b/nautilus/test/data/expression-tests/after_ssa/incrementPre.trace index a8015585..3f9bc2aa 100644 --- a/nautilus/test/data/expression-tests/after_ssa/incrementPre.trace +++ b/nautilus/test/data/expression-tests/after_ssa/incrementPre.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 1 :i32 ADD $3 $1 $2 :i32 ADD $5 $3 $3 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/int16AddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/int16AddExpression.trace index 8c277633..32392b19 100644 --- a/nautilus/test/data/expression-tests/after_ssa/int16AddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/int16AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i16) CONST $2 5 :i16 ADD $3 $1 $2 :i32 - RETURN $3 :i16 + RETURN $0 $3 :i16 diff --git a/nautilus/test/data/expression-tests/after_ssa/int32AddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/int32AddExpression.trace index 3a79fe61..7f523998 100644 --- a/nautilus/test/data/expression-tests/after_ssa/int32AddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/int32AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 ADD $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/after_ssa/int64AddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/int64AddExpression.trace index dc9a16bf..a3c3d92d 100644 --- a/nautilus/test/data/expression-tests/after_ssa/int64AddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/int64AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i64) CONST $2 7 :i64 ADD $3 $1 $2 :i64 - RETURN $3 :i64 + RETURN $0 $3 :i64 diff --git a/nautilus/test/data/expression-tests/after_ssa/int8AddExpression.trace b/nautilus/test/data/expression-tests/after_ssa/int8AddExpression.trace index 227bcc78..8a9d0642 100644 --- a/nautilus/test/data/expression-tests/after_ssa/int8AddExpression.trace +++ b/nautilus/test/data/expression-tests/after_ssa/int8AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i8) CONST $2 2 :i8 ADD $3 $2 $1 :i32 - RETURN $3 :i8 + RETURN $0 $3 :i8 diff --git a/nautilus/test/data/expression-tests/after_ssa/logicalNot_bool.trace b/nautilus/test/data/expression-tests/after_ssa/logicalNot_bool.trace index 79f08759..7a3c8c72 100644 --- a/nautilus/test/data/expression-tests/after_ssa/logicalNot_bool.trace +++ b/nautilus/test/data/expression-tests/after_ssa/logicalNot_bool.trace @@ -1,3 +1,3 @@ B0($1:bool) NOT $3 $1 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/expression-tests/after_ssa/negate_i8.trace b/nautilus/test/data/expression-tests/after_ssa/negate_i8.trace index 7a59d5f9..c6585985 100644 --- a/nautilus/test/data/expression-tests/after_ssa/negate_i8.trace +++ b/nautilus/test/data/expression-tests/after_ssa/negate_i8.trace @@ -1,3 +1,3 @@ B0($1:i8) NEGATE $3 $1 :i8 - RETURN $3 :i8 + RETURN $0 $3 :i8 diff --git a/nautilus/test/data/expression-tests/after_ssa/shiftLeft_i8.trace b/nautilus/test/data/expression-tests/after_ssa/shiftLeft_i8.trace index 5a1064ef..ad30cfd0 100644 --- a/nautilus/test/data/expression-tests/after_ssa/shiftLeft_i8.trace +++ b/nautilus/test/data/expression-tests/after_ssa/shiftLeft_i8.trace @@ -1,4 +1,4 @@ B0($1:i8,$2:i8) LSH $3 $1 $2 :i32 CAST $4 $3 :i8 - RETURN $4 :i8 + RETURN $0 $4 :i8 diff --git a/nautilus/test/data/expression-tests/after_ssa/shiftRight_i8.trace b/nautilus/test/data/expression-tests/after_ssa/shiftRight_i8.trace index 3ecec5df..305e7f7c 100644 --- a/nautilus/test/data/expression-tests/after_ssa/shiftRight_i8.trace +++ b/nautilus/test/data/expression-tests/after_ssa/shiftRight_i8.trace @@ -1,4 +1,4 @@ B0($1:i8,$2:i8) RSH $3 $1 $2 :i32 CAST $4 $3 :i8 - RETURN $4 :i8 + RETURN $0 $4 :i8 diff --git a/nautilus/test/data/expression-tests/tracing/assignAdd.trace b/nautilus/test/data/expression-tests/tracing/assignAdd.trace index 02416e42..b49627a4 100644 --- a/nautilus/test/data/expression-tests/tracing/assignAdd.trace +++ b/nautilus/test/data/expression-tests/tracing/assignAdd.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 ADD $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignAnd.trace b/nautilus/test/data/expression-tests/tracing/assignAnd.trace index 9f62af0d..f4eb86e4 100644 --- a/nautilus/test/data/expression-tests/tracing/assignAnd.trace +++ b/nautilus/test/data/expression-tests/tracing/assignAnd.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 BAND $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignDiv.trace b/nautilus/test/data/expression-tests/tracing/assignDiv.trace index 52a47840..ce7e75c5 100644 --- a/nautilus/test/data/expression-tests/tracing/assignDiv.trace +++ b/nautilus/test/data/expression-tests/tracing/assignDiv.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 DIV $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignMod.trace b/nautilus/test/data/expression-tests/tracing/assignMod.trace index 4c727152..e1fdd113 100644 --- a/nautilus/test/data/expression-tests/tracing/assignMod.trace +++ b/nautilus/test/data/expression-tests/tracing/assignMod.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 MOD $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignMul.trace b/nautilus/test/data/expression-tests/tracing/assignMul.trace index 2829cd68..3e6b4dd4 100644 --- a/nautilus/test/data/expression-tests/tracing/assignMul.trace +++ b/nautilus/test/data/expression-tests/tracing/assignMul.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 MUL $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignOr.trace b/nautilus/test/data/expression-tests/tracing/assignOr.trace index eb3daa0b..a3cf3d0e 100644 --- a/nautilus/test/data/expression-tests/tracing/assignOr.trace +++ b/nautilus/test/data/expression-tests/tracing/assignOr.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 BOR $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignShl.trace b/nautilus/test/data/expression-tests/tracing/assignShl.trace index 0468c4d6..36d3d30c 100644 --- a/nautilus/test/data/expression-tests/tracing/assignShl.trace +++ b/nautilus/test/data/expression-tests/tracing/assignShl.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 LSH $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignShr.trace b/nautilus/test/data/expression-tests/tracing/assignShr.trace index d5a30365..22e49d12 100644 --- a/nautilus/test/data/expression-tests/tracing/assignShr.trace +++ b/nautilus/test/data/expression-tests/tracing/assignShr.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 RSH $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignSub.trace b/nautilus/test/data/expression-tests/tracing/assignSub.trace index 784bbe91..546cc169 100644 --- a/nautilus/test/data/expression-tests/tracing/assignSub.trace +++ b/nautilus/test/data/expression-tests/tracing/assignSub.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 SUB $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignXor.trace b/nautilus/test/data/expression-tests/tracing/assignXor.trace index afb1637c..b4a537c4 100644 --- a/nautilus/test/data/expression-tests/tracing/assignXor.trace +++ b/nautilus/test/data/expression-tests/tracing/assignXor.trace @@ -2,4 +2,4 @@ B0($1:i32) CONST $2 5 :i32 BXOR $3 $1 $2 :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignment1.trace b/nautilus/test/data/expression-tests/tracing/assignment1.trace index 7e125e8f..0555d61f 100644 --- a/nautilus/test/data/expression-tests/tracing/assignment1.trace +++ b/nautilus/test/data/expression-tests/tracing/assignment1.trace @@ -1,3 +1,3 @@ B0($1:i32) ASSIGN $2 $1 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignment2.trace b/nautilus/test/data/expression-tests/tracing/assignment2.trace index ad0e3628..c0fbcf86 100644 --- a/nautilus/test/data/expression-tests/tracing/assignment2.trace +++ b/nautilus/test/data/expression-tests/tracing/assignment2.trace @@ -3,4 +3,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $2 $3 :i32 ASSIGN $2 $4 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignment3.trace b/nautilus/test/data/expression-tests/tracing/assignment3.trace index 9d368893..c1c4edb0 100644 --- a/nautilus/test/data/expression-tests/tracing/assignment3.trace +++ b/nautilus/test/data/expression-tests/tracing/assignment3.trace @@ -3,4 +3,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $2 $3 :i32 ASSIGN $2 $4 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignment4.trace b/nautilus/test/data/expression-tests/tracing/assignment4.trace index 2c646c36..5baa8834 100644 --- a/nautilus/test/data/expression-tests/tracing/assignment4.trace +++ b/nautilus/test/data/expression-tests/tracing/assignment4.trace @@ -3,4 +3,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $1 $3 :i32 ASSIGN $2 $4 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/assignment5.trace b/nautilus/test/data/expression-tests/tracing/assignment5.trace index 7c79546b..2ae209fd 100644 --- a/nautilus/test/data/expression-tests/tracing/assignment5.trace +++ b/nautilus/test/data/expression-tests/tracing/assignment5.trace @@ -3,4 +3,4 @@ B0($1:i32) CONST $3 1 :i32 ADD $4 $1 $3 :i32 ASSIGN $2 $4 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/castFloatToDoubleAddExpression.trace b/nautilus/test/data/expression-tests/tracing/castFloatToDoubleAddExpression.trace index b3d5aef5..2acf8a2a 100644 --- a/nautilus/test/data/expression-tests/tracing/castFloatToDoubleAddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/castFloatToDoubleAddExpression.trace @@ -2,4 +2,4 @@ B0($1:f32) CONST $2 7 :f64 CAST $3 $1 :f64 ADD $4 $3 $2 :f64 - RETURN $4 :f64 + RETURN $0 $4 :f64 diff --git a/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression.trace b/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression.trace index 30d667b2..fe034cfb 100644 --- a/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression.trace @@ -2,4 +2,4 @@ B0($1:i8) CONST $2 7 :i64 CAST $3 $1 :i64 ADD $4 $3 $2 :i64 - RETURN $4 :i64 + RETURN $0 $4 :i64 diff --git a/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression2.trace b/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression2.trace index 313c3fc0..02e4ce0d 100644 --- a/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression2.trace +++ b/nautilus/test/data/expression-tests/tracing/castInt8ToInt64AddExpression2.trace @@ -2,4 +2,4 @@ B0($1:i8) CONST $2 42 :i64 CAST $3 $1 :i64 ADD $4 $2 $3 :i64 - RETURN $4 :i64 + RETURN $0 $4 :i64 diff --git a/nautilus/test/data/expression-tests/tracing/decrementPost.trace b/nautilus/test/data/expression-tests/tracing/decrementPost.trace index 87b3ce4e..e4990884 100644 --- a/nautilus/test/data/expression-tests/tracing/decrementPost.trace +++ b/nautilus/test/data/expression-tests/tracing/decrementPost.trace @@ -4,4 +4,4 @@ B0($1:i32) SUB $4 $1 $3 :i32 ASSIGN $1 $4 :i32 ADD $5 $2 $1 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/decrementPre.trace b/nautilus/test/data/expression-tests/tracing/decrementPre.trace index 6f8c790f..45842924 100644 --- a/nautilus/test/data/expression-tests/tracing/decrementPre.trace +++ b/nautilus/test/data/expression-tests/tracing/decrementPre.trace @@ -4,4 +4,4 @@ B0($1:i32) ASSIGN $1 $3 :i32 ASSIGN $4 $1 :i32 ADD $5 $4 $1 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/doubleAddExpression.trace b/nautilus/test/data/expression-tests/tracing/doubleAddExpression.trace index b7b9549d..e86029f0 100644 --- a/nautilus/test/data/expression-tests/tracing/doubleAddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/doubleAddExpression.trace @@ -1,4 +1,4 @@ B0($1:f64) CONST $2 7 :f64 ADD $3 $1 $2 :f64 - RETURN $3 :f64 + RETURN $0 $3 :f64 diff --git a/nautilus/test/data/expression-tests/tracing/floatAddExpression.trace b/nautilus/test/data/expression-tests/tracing/floatAddExpression.trace index 055d89bf..6081486e 100644 --- a/nautilus/test/data/expression-tests/tracing/floatAddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/floatAddExpression.trace @@ -1,4 +1,4 @@ B0($1:f32) CONST $2 7 :f32 ADD $3 $1 $2 :f32 - RETURN $3 :f32 + RETURN $0 $3 :f32 diff --git a/nautilus/test/data/expression-tests/tracing/incrementPost.trace b/nautilus/test/data/expression-tests/tracing/incrementPost.trace index c96c1fbb..fc19a7b1 100644 --- a/nautilus/test/data/expression-tests/tracing/incrementPost.trace +++ b/nautilus/test/data/expression-tests/tracing/incrementPost.trace @@ -4,4 +4,4 @@ B0($1:i32) ADD $4 $1 $3 :i32 ASSIGN $1 $4 :i32 ADD $5 $2 $1 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/incrementPre.trace b/nautilus/test/data/expression-tests/tracing/incrementPre.trace index 74fd71c4..d9d816cc 100644 --- a/nautilus/test/data/expression-tests/tracing/incrementPre.trace +++ b/nautilus/test/data/expression-tests/tracing/incrementPre.trace @@ -4,4 +4,4 @@ B0($1:i32) ASSIGN $1 $3 :i32 ASSIGN $4 $1 :i32 ADD $5 $4 $1 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/int16AddExpression.trace b/nautilus/test/data/expression-tests/tracing/int16AddExpression.trace index 8c277633..32392b19 100644 --- a/nautilus/test/data/expression-tests/tracing/int16AddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/int16AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i16) CONST $2 5 :i16 ADD $3 $1 $2 :i32 - RETURN $3 :i16 + RETURN $0 $3 :i16 diff --git a/nautilus/test/data/expression-tests/tracing/int32AddExpression.trace b/nautilus/test/data/expression-tests/tracing/int32AddExpression.trace index 3a79fe61..7f523998 100644 --- a/nautilus/test/data/expression-tests/tracing/int32AddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/int32AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i32) CONST $2 5 :i32 ADD $3 $1 $2 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/expression-tests/tracing/int64AddExpression.trace b/nautilus/test/data/expression-tests/tracing/int64AddExpression.trace index dc9a16bf..a3c3d92d 100644 --- a/nautilus/test/data/expression-tests/tracing/int64AddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/int64AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i64) CONST $2 7 :i64 ADD $3 $1 $2 :i64 - RETURN $3 :i64 + RETURN $0 $3 :i64 diff --git a/nautilus/test/data/expression-tests/tracing/int8AddExpression.trace b/nautilus/test/data/expression-tests/tracing/int8AddExpression.trace index 227bcc78..8a9d0642 100644 --- a/nautilus/test/data/expression-tests/tracing/int8AddExpression.trace +++ b/nautilus/test/data/expression-tests/tracing/int8AddExpression.trace @@ -1,4 +1,4 @@ B0($1:i8) CONST $2 2 :i8 ADD $3 $2 $1 :i32 - RETURN $3 :i8 + RETURN $0 $3 :i8 diff --git a/nautilus/test/data/expression-tests/tracing/logicalNot_bool.trace b/nautilus/test/data/expression-tests/tracing/logicalNot_bool.trace index f3b0e700..9fb62049 100644 --- a/nautilus/test/data/expression-tests/tracing/logicalNot_bool.trace +++ b/nautilus/test/data/expression-tests/tracing/logicalNot_bool.trace @@ -1,4 +1,4 @@ B0($1:bool) ASSIGN $2 $1 :bool NOT $3 $2 :bool - RETURN $3 :bool + RETURN $0 $3 :bool diff --git a/nautilus/test/data/expression-tests/tracing/negate_i8.trace b/nautilus/test/data/expression-tests/tracing/negate_i8.trace index bf6272a3..ecf93b9f 100644 --- a/nautilus/test/data/expression-tests/tracing/negate_i8.trace +++ b/nautilus/test/data/expression-tests/tracing/negate_i8.trace @@ -1,4 +1,4 @@ B0($1:i8) ASSIGN $2 $1 :i8 NEGATE $3 $2 :i8 - RETURN $3 :i8 + RETURN $0 $3 :i8 diff --git a/nautilus/test/data/expression-tests/tracing/shiftLeft_i8.trace b/nautilus/test/data/expression-tests/tracing/shiftLeft_i8.trace index 5a1064ef..ad30cfd0 100644 --- a/nautilus/test/data/expression-tests/tracing/shiftLeft_i8.trace +++ b/nautilus/test/data/expression-tests/tracing/shiftLeft_i8.trace @@ -1,4 +1,4 @@ B0($1:i8,$2:i8) LSH $3 $1 $2 :i32 CAST $4 $3 :i8 - RETURN $4 :i8 + RETURN $0 $4 :i8 diff --git a/nautilus/test/data/expression-tests/tracing/shiftRight_i8.trace b/nautilus/test/data/expression-tests/tracing/shiftRight_i8.trace index 3ecec5df..305e7f7c 100644 --- a/nautilus/test/data/expression-tests/tracing/shiftRight_i8.trace +++ b/nautilus/test/data/expression-tests/tracing/shiftRight_i8.trace @@ -1,4 +1,4 @@ B0($1:i8,$2:i8) RSH $3 $1 $2 :i32 CAST $4 $3 :i8 - RETURN $4 :i8 + RETURN $0 $4 :i8 diff --git a/nautilus/test/data/loop-tests/after_ssa/collatz.trace b/nautilus/test/data/loop-tests/after_ssa/collatz.trace index d2e88dd8..4e036e06 100644 --- a/nautilus/test/data/loop-tests/after_ssa/collatz.trace +++ b/nautilus/test/data/loop-tests/after_ssa/collatz.trace @@ -9,7 +9,7 @@ B1($2:i32,$1:i32) EQ $9 $7 $8 :bool CMP $10 $9 B3($2,$1) B4($2,$1) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$1:i32) CONST $11 2 :i32 DIV $12 $1 $11 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/countDigits.trace b/nautilus/test/data/loop-tests/after_ssa/countDigits.trace index a1668674..c53ca61f 100644 --- a/nautilus/test/data/loop-tests/after_ssa/countDigits.trace +++ b/nautilus/test/data/loop-tests/after_ssa/countDigits.trace @@ -10,7 +10,7 @@ B1($2:i32,$1:i32) CONST $10 0 :i32 JMP $0 B3($9,$7,$10) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$1:i32,$3:i32) ControlFlowMerge NEQ $4 $1 $3 :bool CMP $5 $4 B1($2,$1) B2($2) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/decimalToBinary.trace b/nautilus/test/data/loop-tests/after_ssa/decimalToBinary.trace index 81ab4892..3127712a 100644 --- a/nautilus/test/data/loop-tests/after_ssa/decimalToBinary.trace +++ b/nautilus/test/data/loop-tests/after_ssa/decimalToBinary.trace @@ -7,7 +7,7 @@ B1($1:i32,$3:i32,$2:i32) CONST $15 2 :i32 JMP $0 B3($1,$3,$2,$15) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($1:i32,$3:i32,$2:i32,$4:i32) ControlFlowMerge MOD $5 $1 $4 :i32 MUL $6 $5 $3 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/digitSum.trace b/nautilus/test/data/loop-tests/after_ssa/digitSum.trace index 89edc7bd..9520506f 100644 --- a/nautilus/test/data/loop-tests/after_ssa/digitSum.trace +++ b/nautilus/test/data/loop-tests/after_ssa/digitSum.trace @@ -6,7 +6,7 @@ B1($1:i32,$2:i32) CONST $11 10 :i32 JMP $0 B3($1,$2,$11) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($1:i32,$2:i32,$3:i32) ControlFlowMerge MOD $4 $1 $3 :i32 ADD $5 $2 $4 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/elseOnlySumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/elseOnlySumLoop.trace index eca4364a..458f8912 100644 --- a/nautilus/test/data/loop-tests/after_ssa/elseOnlySumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/elseOnlySumLoop.trace @@ -8,7 +8,7 @@ B1($1:i32,$2:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($1,$2) B4($2,$1) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($1:i32,$2:i32) CONST $9 1 :i32 JMP $0 B6($1,$2,$9) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/factorial.trace b/nautilus/test/data/loop-tests/after_ssa/factorial.trace index 13613a78..486fb8f0 100644 --- a/nautilus/test/data/loop-tests/after_ssa/factorial.trace +++ b/nautilus/test/data/loop-tests/after_ssa/factorial.trace @@ -9,7 +9,7 @@ B1($1:i32,$2:i32) CONST $10 1 :i32 JMP $0 B3($7,$9,$10) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$1:i32,$3:i32) ControlFlowMerge GT $4 $1 $3 :bool CMP $5 $4 B1($1,$2) B2($2) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/fibonacci.trace b/nautilus/test/data/loop-tests/after_ssa/fibonacci.trace index 9c569106..09f6ead4 100644 --- a/nautilus/test/data/loop-tests/after_ssa/fibonacci.trace +++ b/nautilus/test/data/loop-tests/after_ssa/fibonacci.trace @@ -10,7 +10,7 @@ B1($1:i32,$5:i32,$3:i32,$2:i32) ADD $10 $5 $9 :i32 JMP $0 B3($8,$10,$1,$3) :void B2($3:i32) - RETURN $3 :i32 + RETURN $0 $3 :i32 B3($3:i32,$5:i32,$1:i32,$2:i32) ControlFlowMerge LTE $6 $5 $1 :bool CMP $7 $6 B1($1,$5,$3,$2) B2($3) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/gcd.trace b/nautilus/test/data/loop-tests/after_ssa/gcd.trace index ae7219dc..b845c84f 100644 --- a/nautilus/test/data/loop-tests/after_ssa/gcd.trace +++ b/nautilus/test/data/loop-tests/after_ssa/gcd.trace @@ -6,7 +6,7 @@ B1($1:i32,$2:i32) CONST $8 0 :i32 JMP $0 B3($2,$7,$8) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($1:i32,$2:i32,$3:i32) ControlFlowMerge NEQ $4 $2 $3 :bool CMP $5 $4 B1($1,$2) B2($1) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/ifElseSumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/ifElseSumLoop.trace index 9bcfb3a0..d2210656 100644 --- a/nautilus/test/data/loop-tests/after_ssa/ifElseSumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/ifElseSumLoop.trace @@ -8,7 +8,7 @@ B1($2:i32,$1:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($2,$1) B4($2,$1) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($2:i32,$1:i32) CONST $9 10 :i32 ADD $10 $1 $9 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/ifInsideLoop.trace b/nautilus/test/data/loop-tests/after_ssa/ifInsideLoop.trace index 8dfb299d..d0b56759 100644 --- a/nautilus/test/data/loop-tests/after_ssa/ifInsideLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/ifInsideLoop.trace @@ -9,7 +9,7 @@ B1($1:i32,$3:i32,$2:i32) EQ $9 $7 $8 :bool CMP $10 $9 B3($1,$3,$2) B4($2,$1,$3) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($1:i32,$3:i32,$2:i32) CONST $11 1 :i32 ADD $12 $2 $11 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/ifSumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/ifSumLoop.trace index 79b1b4c0..27ba2c3b 100644 --- a/nautilus/test/data/loop-tests/after_ssa/ifSumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/ifSumLoop.trace @@ -8,7 +8,7 @@ B1($2:i32,$1:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($2,$1) B4($1,$2) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($2:i32,$1:i32) CONST $9 10 :i32 ADD $10 $1 $9 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/isPrime.trace b/nautilus/test/data/loop-tests/after_ssa/isPrime.trace index 101e255f..294414ec 100644 --- a/nautilus/test/data/loop-tests/after_ssa/isPrime.trace +++ b/nautilus/test/data/loop-tests/after_ssa/isPrime.trace @@ -27,4 +27,4 @@ B7($2:bool,$1:i32,$8:i32,$3:bool) ControlFlowMerge LTE $10 $9 $1 :bool CMP $11 $10 B3($2,$1,$8,$3) B4($3) :void B8($2:bool) - RETURN $2 :bool + RETURN $0 $2 :bool diff --git a/nautilus/test/data/loop-tests/after_ssa/nestedElseOnlySumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/nestedElseOnlySumLoop.trace index 38ce3541..0348ebcc 100644 --- a/nautilus/test/data/loop-tests/after_ssa/nestedElseOnlySumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/nestedElseOnlySumLoop.trace @@ -8,7 +8,7 @@ B1($1:i32,$2:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($1,$2) B4($2,$1) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($1:i32,$2:i32) CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/after_ssa/nestedIfElseSumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/nestedIfElseSumLoop.trace index c441953d..92c6a878 100644 --- a/nautilus/test/data/loop-tests/after_ssa/nestedIfElseSumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/nestedIfElseSumLoop.trace @@ -8,7 +8,7 @@ B1($2:i32,$1:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($2,$1) B4($2,$1) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($2:i32,$1:i32) CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/after_ssa/nestedIfSumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/nestedIfSumLoop.trace index b05dcd5d..1846128d 100644 --- a/nautilus/test/data/loop-tests/after_ssa/nestedIfSumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/nestedIfSumLoop.trace @@ -8,7 +8,7 @@ B1($2:i32,$1:i32) LT $7 $1 $6 :bool CMP $8 $7 B3($2,$1) B4($2,$1) :void B2($1:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 B3($2:i32,$1:i32) CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/after_ssa/nestedSumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/nestedSumLoop.trace index ac744773..6e809b2d 100644 --- a/nautilus/test/data/loop-tests/after_ssa/nestedSumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/nestedSumLoop.trace @@ -6,7 +6,7 @@ B1($2:i32,$1:i32,$3:i32) CONST $6 0 :i32 JMP $0 B5($2,$1,$3,$6) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($1:i32,$3:i32,$6:i32,$2:i32) CONST $9 10 :i32 ADD $10 $2 $9 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/reverseNumber.trace b/nautilus/test/data/loop-tests/after_ssa/reverseNumber.trace index 88884594..676b897a 100644 --- a/nautilus/test/data/loop-tests/after_ssa/reverseNumber.trace +++ b/nautilus/test/data/loop-tests/after_ssa/reverseNumber.trace @@ -6,7 +6,7 @@ B1($1:i32,$2:i32) CONST $13 10 :i32 JMP $0 B3($1,$2,$13) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($1:i32,$2:i32,$3:i32) ControlFlowMerge MUL $4 $2 $3 :i32 CONST $5 10 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/sumLoop.trace b/nautilus/test/data/loop-tests/after_ssa/sumLoop.trace index 44e7eb29..8b7ad459 100644 --- a/nautilus/test/data/loop-tests/after_ssa/sumLoop.trace +++ b/nautilus/test/data/loop-tests/after_ssa/sumLoop.trace @@ -9,7 +9,7 @@ B1($1:i32,$3:i32,$2:i32) ADD $9 $3 $8 :i32 JMP $0 B3($7,$9,$1) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$3:i32,$1:i32) ControlFlowMerge LT $4 $3 $1 :bool CMP $5 $4 B1($1,$3,$2) B2($2) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/sumOfNumbers.trace b/nautilus/test/data/loop-tests/after_ssa/sumOfNumbers.trace index c98fcf32..c2393e1e 100644 --- a/nautilus/test/data/loop-tests/after_ssa/sumOfNumbers.trace +++ b/nautilus/test/data/loop-tests/after_ssa/sumOfNumbers.trace @@ -8,7 +8,7 @@ B1($1:i32,$3:i32,$2:i32) ADD $9 $3 $8 :i32 JMP $0 B3($7,$9,$1) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$3:i32,$1:i32) ControlFlowMerge LTE $4 $3 $1 :bool CMP $5 $4 B1($1,$3,$2) B2($2) :void diff --git a/nautilus/test/data/loop-tests/after_ssa/sumOfSquares.trace b/nautilus/test/data/loop-tests/after_ssa/sumOfSquares.trace index 01f24bfd..7f223b5c 100644 --- a/nautilus/test/data/loop-tests/after_ssa/sumOfSquares.trace +++ b/nautilus/test/data/loop-tests/after_ssa/sumOfSquares.trace @@ -9,7 +9,7 @@ B1($1:i32,$3:i32,$2:i32) ADD $9 $3 $8 :i32 JMP $0 B3($7,$9,$1) :void B2($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 B3($2:i32,$3:i32,$1:i32) ControlFlowMerge LTE $4 $3 $1 :bool CMP $5 $4 B1($1,$3,$2) B2($2) :void diff --git a/nautilus/test/data/loop-tests/tracing/collatz.trace b/nautilus/test/data/loop-tests/tracing/collatz.trace index a290e0a8..e72afba3 100644 --- a/nautilus/test/data/loop-tests/tracing/collatz.trace +++ b/nautilus/test/data/loop-tests/tracing/collatz.trace @@ -9,7 +9,7 @@ B1() EQ $9 $7 $8 :bool CMP $10 $9 B3() B4() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() CONST $11 2 :i32 DIV $12 $1 $11 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/countDigits.trace b/nautilus/test/data/loop-tests/tracing/countDigits.trace index 056df9e2..607111b7 100644 --- a/nautilus/test/data/loop-tests/tracing/countDigits.trace +++ b/nautilus/test/data/loop-tests/tracing/countDigits.trace @@ -13,7 +13,7 @@ B1() ASSIGN $3 $10 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge NEQ $4 $1 $3 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/decimalToBinary.trace b/nautilus/test/data/loop-tests/tracing/decimalToBinary.trace index 44768259..384da934 100644 --- a/nautilus/test/data/loop-tests/tracing/decimalToBinary.trace +++ b/nautilus/test/data/loop-tests/tracing/decimalToBinary.trace @@ -8,7 +8,7 @@ B1() ASSIGN $4 $15 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge MOD $5 $1 $4 :i32 MUL $6 $5 $3 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/digitSum.trace b/nautilus/test/data/loop-tests/tracing/digitSum.trace index 820fbb10..f482c983 100644 --- a/nautilus/test/data/loop-tests/tracing/digitSum.trace +++ b/nautilus/test/data/loop-tests/tracing/digitSum.trace @@ -7,7 +7,7 @@ B1() ASSIGN $3 $11 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge MOD $4 $1 $3 :i32 ADD $5 $2 $4 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/elseOnlySumLoop.trace b/nautilus/test/data/loop-tests/tracing/elseOnlySumLoop.trace index 037edd8d..6dd3b155 100644 --- a/nautilus/test/data/loop-tests/tracing/elseOnlySumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/elseOnlySumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 1 :i32 JMP $0 B6() :void diff --git a/nautilus/test/data/loop-tests/tracing/factorial.trace b/nautilus/test/data/loop-tests/tracing/factorial.trace index f33459d0..abb54b94 100644 --- a/nautilus/test/data/loop-tests/tracing/factorial.trace +++ b/nautilus/test/data/loop-tests/tracing/factorial.trace @@ -13,7 +13,7 @@ B1() ASSIGN $3 $10 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge GT $4 $1 $3 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/fibonacci.trace b/nautilus/test/data/loop-tests/tracing/fibonacci.trace index a58cf042..3e6f96a3 100644 --- a/nautilus/test/data/loop-tests/tracing/fibonacci.trace +++ b/nautilus/test/data/loop-tests/tracing/fibonacci.trace @@ -14,7 +14,7 @@ B1() ASSIGN $5 $10 :i32 JMP $0 B3() :void B2() - RETURN $3 :i32 + RETURN $0 $3 :i32 B3() ControlFlowMerge LTE $6 $5 $1 :bool CMP $7 $6 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/gcd.trace b/nautilus/test/data/loop-tests/tracing/gcd.trace index 2964f21c..33082ccb 100644 --- a/nautilus/test/data/loop-tests/tracing/gcd.trace +++ b/nautilus/test/data/loop-tests/tracing/gcd.trace @@ -10,7 +10,7 @@ B1() ASSIGN $3 $8 :i32 JMP $0 B3() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() ControlFlowMerge NEQ $4 $2 $3 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/ifElseSumLoop.trace b/nautilus/test/data/loop-tests/tracing/ifElseSumLoop.trace index fdf72807..499a892e 100644 --- a/nautilus/test/data/loop-tests/tracing/ifElseSumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/ifElseSumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 10 :i32 ADD $10 $1 $9 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/ifInsideLoop.trace b/nautilus/test/data/loop-tests/tracing/ifInsideLoop.trace index 22a1de17..44ff9a49 100644 --- a/nautilus/test/data/loop-tests/tracing/ifInsideLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/ifInsideLoop.trace @@ -9,7 +9,7 @@ B1() EQ $9 $7 $8 :bool CMP $10 $9 B3() B4() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() CONST $11 1 :i32 ADD $12 $2 $11 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/ifSumLoop.trace b/nautilus/test/data/loop-tests/tracing/ifSumLoop.trace index 0cdbdee5..40d40d2c 100644 --- a/nautilus/test/data/loop-tests/tracing/ifSumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/ifSumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 10 :i32 ADD $10 $1 $9 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/isPrime.trace b/nautilus/test/data/loop-tests/tracing/isPrime.trace index c174b08e..70326d58 100644 --- a/nautilus/test/data/loop-tests/tracing/isPrime.trace +++ b/nautilus/test/data/loop-tests/tracing/isPrime.trace @@ -5,7 +5,7 @@ B0($1:i32) LTE $5 $1 $4 :bool CMP $6 $5 B1() B2() :void B1() - RETURN $2 :bool + RETURN $0 $2 :bool B2() CONST $8 2 :i32 JMP $0 B7() :void @@ -15,9 +15,9 @@ B3() EQ $14 $12 $13 :bool CMP $15 $14 B5() B6() :void B4() - RETURN $3 :bool + RETURN $0 $3 :bool B5() - RETURN $2 :bool + RETURN $0 $2 :bool B6() CONST $18 1 :i32 ADD $19 $8 $18 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/nestedElseOnlySumLoop.trace b/nautilus/test/data/loop-tests/tracing/nestedElseOnlySumLoop.trace index f09f5824..03661a26 100644 --- a/nautilus/test/data/loop-tests/tracing/nestedElseOnlySumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/nestedElseOnlySumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/tracing/nestedIfElseSumLoop.trace b/nautilus/test/data/loop-tests/tracing/nestedIfElseSumLoop.trace index 566b55d7..306f3b5a 100644 --- a/nautilus/test/data/loop-tests/tracing/nestedIfElseSumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/nestedIfElseSumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/tracing/nestedIfSumLoop.trace b/nautilus/test/data/loop-tests/tracing/nestedIfSumLoop.trace index 9eea02c0..219d9020 100644 --- a/nautilus/test/data/loop-tests/tracing/nestedIfSumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/nestedIfSumLoop.trace @@ -8,7 +8,7 @@ B1() LT $7 $1 $6 :bool CMP $8 $7 B3() B4() :void B2() - RETURN $1 :i32 + RETURN $0 $1 :i32 B3() CONST $9 40 :i32 LT $10 $1 $9 :bool diff --git a/nautilus/test/data/loop-tests/tracing/nestedSumLoop.trace b/nautilus/test/data/loop-tests/tracing/nestedSumLoop.trace index 3cc548a3..5fca13e9 100644 --- a/nautilus/test/data/loop-tests/tracing/nestedSumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/nestedSumLoop.trace @@ -6,7 +6,7 @@ B1() CONST $6 0 :i32 JMP $0 B5() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() CONST $9 10 :i32 ADD $10 $2 $9 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/reverseNumber.trace b/nautilus/test/data/loop-tests/tracing/reverseNumber.trace index b97ab3d6..8ff1c794 100644 --- a/nautilus/test/data/loop-tests/tracing/reverseNumber.trace +++ b/nautilus/test/data/loop-tests/tracing/reverseNumber.trace @@ -7,7 +7,7 @@ B1() ASSIGN $3 $13 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge MUL $4 $2 $3 :i32 CONST $5 10 :i32 diff --git a/nautilus/test/data/loop-tests/tracing/sumLoop.trace b/nautilus/test/data/loop-tests/tracing/sumLoop.trace index 47e3307f..51263347 100644 --- a/nautilus/test/data/loop-tests/tracing/sumLoop.trace +++ b/nautilus/test/data/loop-tests/tracing/sumLoop.trace @@ -11,7 +11,7 @@ B1() ASSIGN $3 $9 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge LT $4 $3 $1 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/sumOfNumbers.trace b/nautilus/test/data/loop-tests/tracing/sumOfNumbers.trace index 1b060bdd..56d34e42 100644 --- a/nautilus/test/data/loop-tests/tracing/sumOfNumbers.trace +++ b/nautilus/test/data/loop-tests/tracing/sumOfNumbers.trace @@ -11,7 +11,7 @@ B1() ASSIGN $3 $9 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge LTE $4 $3 $1 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/loop-tests/tracing/sumOfSquares.trace b/nautilus/test/data/loop-tests/tracing/sumOfSquares.trace index 89b4bda2..b0738b63 100644 --- a/nautilus/test/data/loop-tests/tracing/sumOfSquares.trace +++ b/nautilus/test/data/loop-tests/tracing/sumOfSquares.trace @@ -11,7 +11,7 @@ B1() ASSIGN $3 $9 :i32 JMP $0 B3() :void B2() - RETURN $2 :i32 + RETURN $0 $2 :i32 B3() ControlFlowMerge LTE $4 $3 $1 :bool CMP $5 $4 B1() B2() :void diff --git a/nautilus/test/data/pointer-tests/after_ssa/addArray_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/addArray_i8.trace index c2385e7f..8ec03fed 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/addArray_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/addArray_i8.trace @@ -20,12 +20,12 @@ B1($3:i8,$4:i8,$1:ptr,$2:ptr) CAST $35 $30 :ui64 MUL $36 $35 $34 :ui64 ADD $37 $1 $36 :ptr - STORE $37 $29 :i8 - CONST $40 1 :i32 - CAST $41 $4 :i32 - ADD $42 $41 $40 :i32 - CAST $43 $42 :i8 - JMP $0 B3($43,$3,$1,$2) :void + STORE $40 $37 $29 :void + CONST $41 1 :i32 + CAST $42 $4 :i32 + ADD $43 $42 $41 :i32 + CAST $44 $43 :i8 + JMP $0 B3($44,$3,$1,$2) :void B2() RETURN $0 :void B3($4:i8,$3:i8,$1:ptr,$2:ptr) ControlFlowMerge diff --git a/nautilus/test/data/pointer-tests/after_ssa/callMemcpy.trace b/nautilus/test/data/pointer-tests/after_ssa/callMemcpy.trace index 58ff292e..66d18688 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/callMemcpy.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/callMemcpy.trace @@ -1,4 +1,4 @@ B0($1:ptr,$2:ptr) CONST $3 0 :ui64 - CALL $4 nautilus::memcpy(nautilus::val, nautilus::val, nautilus::val)::$_0::__invoke(void*, void const*, unsigned long)($2,$1,$3) :ptr + CALL $4 _ZZN8nautilus6memcpyENS_3valIPvEENS0_IPKvEENS0_ImEEEN3$_08__invokeES1_S4_m($2,$1,$3) :ptr RETURN $0 :void diff --git a/nautilus/test/data/pointer-tests/after_ssa/castCustomClass.trace b/nautilus/test/data/pointer-tests/after_ssa/castCustomClass.trace index ed4f0666..3c093fcc 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/castCustomClass.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/castCustomClass.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::castCustomClass(nautilus::val)::$_1::__invoke(nautilus::CustomClass*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus15castCustomClassENS_3valIPNS_9BaseClassEEEEN3$_18__invokeEPNS_11CustomClassE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/castPtrAndGetValue_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/castPtrAndGetValue_i8.trace index 8ea721e6..65b410be 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/castPtrAndGetValue_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/castPtrAndGetValue_i8.trace @@ -5,4 +5,4 @@ B0($1:ptr) MUL $8 $7 $6 :ui64 ADD $9 $1 $8 :ptr LOAD $12 $9 :i16 - RETURN $12 :i16 + RETURN $0 $12 :i16 diff --git a/nautilus/test/data/pointer-tests/after_ssa/castVoidPtr.trace b/nautilus/test/data/pointer-tests/after_ssa/castVoidPtr.trace index b865ab23..56dcdea6 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/castVoidPtr.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/castVoidPtr.trace @@ -5,4 +5,4 @@ B0($1:ptr) MUL $8 $7 $6 :ui64 ADD $9 $1 $8 :ptr LOAD $12 $9 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/customPointerAdd.trace b/nautilus/test/data/pointer-tests/after_ssa/customPointerAdd.trace index 9cbd0665..a21216d1 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/customPointerAdd.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/customPointerAdd.trace @@ -3,4 +3,4 @@ B0($1:ptr,$2:i32) CAST $7 $2 :ui64 MUL $8 $7 $6 :ui64 ADD $9 $1 $8 :ptr - RETURN $9 :ptr + RETURN $0 $9 :ptr diff --git a/nautilus/test/data/pointer-tests/after_ssa/isNullptr_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/isNullptr_i8.trace index 582ef240..27ed351f 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/isNullptr_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/isNullptr_i8.trace @@ -1,4 +1,4 @@ B0($1:ptr) CONST $3 * :ptr EQ $6 $1 $3 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/load.trace b/nautilus/test/data/pointer-tests/after_ssa/load.trace index 8a02d45d..e6978d7e 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/load.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/load.trace @@ -4,4 +4,4 @@ B0($1:ptr,$2:i32) MUL $9 $8 $7 :ui64 ADD $10 $1 $9 :ptr LOAD $13 $10 :i32 - RETURN $13 :i32 + RETURN $0 $13 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace b/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace index c00075ee..972f30cb 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace @@ -1,4 +1,4 @@ B0() CONST $1 * :ptr LOAD $4 $1 :i32 - RETURN $4 :i32 + RETURN $0 $4 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/passCustomClass.trace b/nautilus/test/data/pointer-tests/after_ssa/passCustomClass.trace index 23b339e6..673a0be4 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/passCustomClass.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/passCustomClass.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::passCustomClass(nautilus::val)::$_0::__invoke(nautilus::CustomClass*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus15passCustomClassENS_3valIPNS_11CustomClassEEEEN3$_08__invokeES2_($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/pointerAdd.trace b/nautilus/test/data/pointer-tests/after_ssa/pointerAdd.trace index 6ffeeb01..6cb5a36c 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/pointerAdd.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/pointerAdd.trace @@ -4,4 +4,4 @@ B0($1:ptr,$2:i32) MUL $8 $7 $6 :ui64 ADD $9 $1 $8 :ptr LOAD $12 $9 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/pointerAddConst.trace b/nautilus/test/data/pointer-tests/after_ssa/pointerAddConst.trace index 70f99070..f26e5023 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/pointerAddConst.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/pointerAddConst.trace @@ -4,4 +4,4 @@ B0($1:ptr) MUL $6 $3 $5 :ui64 ADD $7 $1 $6 :ptr LOAD $10 $7 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/pointerSub.trace b/nautilus/test/data/pointer-tests/after_ssa/pointerSub.trace index 426117de..04d7d472 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/pointerSub.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/pointerSub.trace @@ -6,4 +6,4 @@ B0($1:ptr,$2:i32) MUL $9 $8 $7 :ui64 ADD $10 $1 $9 :ptr LOAD $13 $10 :i32 - RETURN $13 :i32 + RETURN $0 $13 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/pointerSubConst.trace b/nautilus/test/data/pointer-tests/after_ssa/pointerSubConst.trace index e96ec4d5..15eeb2ce 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/pointerSubConst.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/pointerSubConst.trace @@ -4,4 +4,4 @@ B0($1:ptr) MUL $6 $3 $5 :ui64 ADD $7 $1 $6 :ptr LOAD $10 $7 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrAssignment.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrAssignment.trace index 5e00749f..970c662f 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrAssignment.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrAssignment.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) LOAD $6 $2 :i32 LOAD $9 $1 :i32 ADD $10 $6 $9 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrEquals_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrEquals_i8.trace index a0e5a4d3..27e0e766 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrEquals_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) EQ $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThanEquals_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThanEquals_i8.trace index 591adafb..f021e59c 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThanEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThanEquals_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) GTE $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThan_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThan_i8.trace index 478593db..dc92e48e 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThan_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrGreaterThan_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) GT $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrLessThanEquals_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrLessThanEquals_i8.trace index a7019122..a3300689 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrLessThanEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrLessThanEquals_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) LTE $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrLessThan_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrLessThan_i8.trace index 5537a8d9..a195c147 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrLessThan_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrLessThan_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) LT $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/ptrNotEquals_i8.trace b/nautilus/test/data/pointer-tests/after_ssa/ptrNotEquals_i8.trace index 0166a82e..63b3365c 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/ptrNotEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/ptrNotEquals_i8.trace @@ -1,3 +1,3 @@ B0($1:ptr,$2:ptr) NEQ $5 $1 $2 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/specializeType.trace b/nautilus/test/data/pointer-tests/after_ssa/specializeType.trace index 37680284..a3fe6759 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/specializeType.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/specializeType.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/after_ssa/sumArray.trace b/nautilus/test/data/pointer-tests/after_ssa/sumArray.trace index ae9c7599..92cdf338 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/sumArray.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/sumArray.trace @@ -13,7 +13,7 @@ B1($2:i32,$4:i32,$3:i32,$1:ptr) ADD $20 $4 $19 :i32 JMP $0 B3($18,$20,$2,$1) :void B2($3:i32) - RETURN $3 :i32 + RETURN $0 $3 :i32 B3($3:i32,$4:i32,$2:i32,$1:ptr) ControlFlowMerge LT $5 $4 $2 :bool CMP $6 $5 B1($2,$4,$3,$1) B2($3) :void diff --git a/nautilus/test/data/pointer-tests/after_ssa/useWrapper.trace b/nautilus/test/data/pointer-tests/after_ssa/useWrapper.trace index c3652e46..8f7ee0e1 100644 --- a/nautilus/test/data/pointer-tests/after_ssa/useWrapper.trace +++ b/nautilus/test/data/pointer-tests/after_ssa/useWrapper.trace @@ -1,5 +1,5 @@ B0($1:ptr,$2:ptr) - CALL $3 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 - CALL $4 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($2) :i32 + CALL $3 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 + CALL $4 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($2) :i32 ADD $5 $3 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/pointer-tests/ir/addArray_i8.trace b/nautilus/test/data/pointer-tests/ir/addArray_i8.trace index 95a5c599..ff5fe1be 100644 --- a/nautilus/test/data/pointer-tests/ir/addArray_i8.trace +++ b/nautilus/test/data/pointer-tests/ir/addArray_i8.trace @@ -28,11 +28,11 @@ Block_1($3:i8, $4:i8, $1:ptr, $2:ptr): $36 = $35 * $34 :ui64 $37 = $1 + $36 :ptr store($29, $37) :void - $40 = 1 :i32 - $41 = $4 cast_to i32 :i32 - $42 = $41 + $40 :i32 - $43 = $42 cast_to i8 :i8 - br Block_3($43, $3, $1, $2) :void + $41 = 1 :i32 + $42 = $4 cast_to i32 :i32 + $43 = $42 + $41 :i32 + $44 = $43 cast_to i8 :i8 + br Block_3($44, $3, $1, $2) :void Block_2(): return :void diff --git a/nautilus/test/data/pointer-tests/ir/callMemcpy.trace b/nautilus/test/data/pointer-tests/ir/callMemcpy.trace index ab0bff81..0fa076db 100644 --- a/nautilus/test/data/pointer-tests/ir/callMemcpy.trace +++ b/nautilus/test/data/pointer-tests/ir/callMemcpy.trace @@ -2,7 +2,7 @@ NautilusIr { execute() { Block_0($1:ptr, $2:ptr): $3 = 0 :ui64 - $4 = nautilus::memcpy(nautilus::val, nautilus::val, nautilus::val)::$_0::__invoke(void*, void const*, unsigned long)($2,$1,$3) :ptr + $4 = _ZZN8nautilus6memcpyENS_3valIPvEENS0_IPKvEENS0_ImEEEN3$_08__invokeES1_S4_m($2,$1,$3) :ptr return :void } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/pointer-tests/ir/castCustomClass.trace b/nautilus/test/data/pointer-tests/ir/castCustomClass.trace index 81c1983a..26e7a5be 100644 --- a/nautilus/test/data/pointer-tests/ir/castCustomClass.trace +++ b/nautilus/test/data/pointer-tests/ir/castCustomClass.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:ptr): - $2 = nautilus::castCustomClass(nautilus::val)::$_1::__invoke(nautilus::CustomClass*)($1) :i32 + $2 = _ZZN8nautilus15castCustomClassENS_3valIPNS_9BaseClassEEEEN3$_18__invokeEPNS_11CustomClassE($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/pointer-tests/ir/passCustomClass.trace b/nautilus/test/data/pointer-tests/ir/passCustomClass.trace index a2cb7a15..6fb49aa3 100644 --- a/nautilus/test/data/pointer-tests/ir/passCustomClass.trace +++ b/nautilus/test/data/pointer-tests/ir/passCustomClass.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:ptr): - $2 = nautilus::passCustomClass(nautilus::val)::$_0::__invoke(nautilus::CustomClass*)($1) :i32 + $2 = _ZZN8nautilus15passCustomClassENS_3valIPNS_11CustomClassEEEEN3$_08__invokeES2_($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/pointer-tests/ir/specializeType.trace b/nautilus/test/data/pointer-tests/ir/specializeType.trace index f82a26bd..273c5765 100644 --- a/nautilus/test/data/pointer-tests/ir/specializeType.trace +++ b/nautilus/test/data/pointer-tests/ir/specializeType.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:ptr): - $2 = nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 + $2 = _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/pointer-tests/ir/useWrapper.trace b/nautilus/test/data/pointer-tests/ir/useWrapper.trace index 7e510680..115cd904 100644 --- a/nautilus/test/data/pointer-tests/ir/useWrapper.trace +++ b/nautilus/test/data/pointer-tests/ir/useWrapper.trace @@ -1,8 +1,8 @@ NautilusIr { execute() { Block_0($1:ptr, $2:ptr): - $3 = nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 - $4 = nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($2) :i32 + $3 = _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 + $4 = _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($2) :i32 $5 = $3 + $4 :i32 return ($5) :i32 } diff --git a/nautilus/test/data/pointer-tests/tracing/addArray_i8.trace b/nautilus/test/data/pointer-tests/tracing/addArray_i8.trace index 17031406..27ce0df1 100644 --- a/nautilus/test/data/pointer-tests/tracing/addArray_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/addArray_i8.trace @@ -35,12 +35,12 @@ B1() ADD $37 $31 $36 :ptr ASSIGN $38 $37 :ptr ASSIGN $39 $38 :ptr - STORE $39 $29 :i8 - CONST $40 1 :i32 - CAST $41 $4 :i32 - ADD $42 $41 $40 :i32 - CAST $43 $42 :i8 - ASSIGN $4 $43 :i8 + STORE $40 $39 $29 :void + CONST $41 1 :i32 + CAST $42 $4 :i32 + ADD $43 $42 $41 :i32 + CAST $44 $43 :i8 + ASSIGN $4 $44 :i8 JMP $0 B3() :void B2() RETURN $0 :void diff --git a/nautilus/test/data/pointer-tests/tracing/callMemcpy.trace b/nautilus/test/data/pointer-tests/tracing/callMemcpy.trace index 58ff292e..66d18688 100644 --- a/nautilus/test/data/pointer-tests/tracing/callMemcpy.trace +++ b/nautilus/test/data/pointer-tests/tracing/callMemcpy.trace @@ -1,4 +1,4 @@ B0($1:ptr,$2:ptr) CONST $3 0 :ui64 - CALL $4 nautilus::memcpy(nautilus::val, nautilus::val, nautilus::val)::$_0::__invoke(void*, void const*, unsigned long)($2,$1,$3) :ptr + CALL $4 _ZZN8nautilus6memcpyENS_3valIPvEENS0_IPKvEENS0_ImEEEN3$_08__invokeES1_S4_m($2,$1,$3) :ptr RETURN $0 :void diff --git a/nautilus/test/data/pointer-tests/tracing/castCustomClass.trace b/nautilus/test/data/pointer-tests/tracing/castCustomClass.trace index ed4f0666..3c093fcc 100644 --- a/nautilus/test/data/pointer-tests/tracing/castCustomClass.trace +++ b/nautilus/test/data/pointer-tests/tracing/castCustomClass.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::castCustomClass(nautilus::val)::$_1::__invoke(nautilus::CustomClass*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus15castCustomClassENS_3valIPNS_9BaseClassEEEEN3$_18__invokeEPNS_11CustomClassE($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/castPtrAndGetValue_i8.trace b/nautilus/test/data/pointer-tests/tracing/castPtrAndGetValue_i8.trace index cdd1d3d4..c28aed32 100644 --- a/nautilus/test/data/pointer-tests/tracing/castPtrAndGetValue_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/castPtrAndGetValue_i8.trace @@ -10,4 +10,4 @@ B0($1:ptr) ASSIGN $10 $9 :ptr ASSIGN $11 $10 :ptr LOAD $12 $11 :i16 - RETURN $12 :i16 + RETURN $0 $12 :i16 diff --git a/nautilus/test/data/pointer-tests/tracing/castVoidPtr.trace b/nautilus/test/data/pointer-tests/tracing/castVoidPtr.trace index 0325d3bd..84d8f4ca 100644 --- a/nautilus/test/data/pointer-tests/tracing/castVoidPtr.trace +++ b/nautilus/test/data/pointer-tests/tracing/castVoidPtr.trace @@ -10,4 +10,4 @@ B0($1:ptr) ASSIGN $10 $9 :ptr ASSIGN $11 $10 :ptr LOAD $12 $11 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/customPointerAdd.trace b/nautilus/test/data/pointer-tests/tracing/customPointerAdd.trace index cf396139..1f2953e8 100644 --- a/nautilus/test/data/pointer-tests/tracing/customPointerAdd.trace +++ b/nautilus/test/data/pointer-tests/tracing/customPointerAdd.trace @@ -6,4 +6,4 @@ B0($1:ptr,$2:i32) CAST $7 $5 :ui64 MUL $8 $7 $6 :ui64 ADD $9 $3 $8 :ptr - RETURN $9 :ptr + RETURN $0 $9 :ptr diff --git a/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace b/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace index 0f55be78..5ce5f440 100644 --- a/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace @@ -4,4 +4,4 @@ B0($1:ptr) ASSIGN $4 $2 :ptr ASSIGN $5 $3 :ptr EQ $6 $4 $5 :bool - RETURN $6 :bool + RETURN $0 $6 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/load.trace b/nautilus/test/data/pointer-tests/tracing/load.trace index c42576c2..4d4f1a3b 100644 --- a/nautilus/test/data/pointer-tests/tracing/load.trace +++ b/nautilus/test/data/pointer-tests/tracing/load.trace @@ -10,4 +10,4 @@ B0($1:ptr,$2:i32) ASSIGN $11 $10 :ptr ASSIGN $12 $11 :ptr LOAD $13 $12 :i32 - RETURN $13 :i32 + RETURN $0 $13 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/loadConst.trace b/nautilus/test/data/pointer-tests/tracing/loadConst.trace index 918c2678..5fb080c2 100644 --- a/nautilus/test/data/pointer-tests/tracing/loadConst.trace +++ b/nautilus/test/data/pointer-tests/tracing/loadConst.trace @@ -3,4 +3,4 @@ B0() ASSIGN $2 $1 :ptr ASSIGN $3 $2 :ptr LOAD $4 $3 :i32 - RETURN $4 :i32 + RETURN $0 $4 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/passCustomClass.trace b/nautilus/test/data/pointer-tests/tracing/passCustomClass.trace index 23b339e6..673a0be4 100644 --- a/nautilus/test/data/pointer-tests/tracing/passCustomClass.trace +++ b/nautilus/test/data/pointer-tests/tracing/passCustomClass.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::passCustomClass(nautilus::val)::$_0::__invoke(nautilus::CustomClass*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus15passCustomClassENS_3valIPNS_11CustomClassEEEEN3$_08__invokeES2_($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/pointerAdd.trace b/nautilus/test/data/pointer-tests/tracing/pointerAdd.trace index 656db759..fb5dfe0d 100644 --- a/nautilus/test/data/pointer-tests/tracing/pointerAdd.trace +++ b/nautilus/test/data/pointer-tests/tracing/pointerAdd.trace @@ -9,4 +9,4 @@ B0($1:ptr,$2:i32) ASSIGN $10 $9 :ptr ASSIGN $11 $10 :ptr LOAD $12 $11 :i32 - RETURN $12 :i32 + RETURN $0 $12 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/pointerAddConst.trace b/nautilus/test/data/pointer-tests/tracing/pointerAddConst.trace index 78254676..6331ceca 100644 --- a/nautilus/test/data/pointer-tests/tracing/pointerAddConst.trace +++ b/nautilus/test/data/pointer-tests/tracing/pointerAddConst.trace @@ -8,4 +8,4 @@ B0($1:ptr) ASSIGN $8 $7 :ptr ASSIGN $9 $8 :ptr LOAD $10 $9 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/pointerSub.trace b/nautilus/test/data/pointer-tests/tracing/pointerSub.trace index 1b4e4a08..8ad6a3ad 100644 --- a/nautilus/test/data/pointer-tests/tracing/pointerSub.trace +++ b/nautilus/test/data/pointer-tests/tracing/pointerSub.trace @@ -10,4 +10,4 @@ B0($1:ptr,$2:i32) ASSIGN $11 $10 :ptr ASSIGN $12 $11 :ptr LOAD $13 $12 :i32 - RETURN $13 :i32 + RETURN $0 $13 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/pointerSubConst.trace b/nautilus/test/data/pointer-tests/tracing/pointerSubConst.trace index d7738352..6a28ec84 100644 --- a/nautilus/test/data/pointer-tests/tracing/pointerSubConst.trace +++ b/nautilus/test/data/pointer-tests/tracing/pointerSubConst.trace @@ -8,4 +8,4 @@ B0($1:ptr) ASSIGN $8 $7 :ptr ASSIGN $9 $8 :ptr LOAD $10 $9 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/ptrAssignment.trace b/nautilus/test/data/pointer-tests/tracing/ptrAssignment.trace index f5d8dabc..f450f459 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrAssignment.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrAssignment.trace @@ -8,4 +8,4 @@ B0($1:ptr,$2:ptr) ASSIGN $8 $7 :ptr LOAD $9 $8 :i32 ADD $10 $6 $9 :i32 - RETURN $10 :i32 + RETURN $0 $10 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/ptrEquals_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrEquals_i8.trace index c16f3b67..96e0720b 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrEquals_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr EQ $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/ptrGreaterThanEquals_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrGreaterThanEquals_i8.trace index dda66429..fc9fa348 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrGreaterThanEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrGreaterThanEquals_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr GTE $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/ptrGreaterThan_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrGreaterThan_i8.trace index dc23a7a1..f7a09344 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrGreaterThan_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrGreaterThan_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr GT $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/ptrLessThanEquals_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrLessThanEquals_i8.trace index dda57765..cb371e22 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrLessThanEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrLessThanEquals_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr LTE $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/ptrLessThan_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrLessThan_i8.trace index 4d3490f5..c861bbbe 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrLessThan_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrLessThan_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr LT $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/ptrNotEquals_i8.trace b/nautilus/test/data/pointer-tests/tracing/ptrNotEquals_i8.trace index 6f7a0db0..be626841 100644 --- a/nautilus/test/data/pointer-tests/tracing/ptrNotEquals_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/ptrNotEquals_i8.trace @@ -2,4 +2,4 @@ B0($1:ptr,$2:ptr) ASSIGN $3 $1 :ptr ASSIGN $4 $2 :ptr NEQ $5 $3 $4 :bool - RETURN $5 :bool + RETURN $0 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/specializeType.trace b/nautilus/test/data/pointer-tests/tracing/specializeType.trace index 37680284..a3fe6759 100644 --- a/nautilus/test/data/pointer-tests/tracing/specializeType.trace +++ b/nautilus/test/data/pointer-tests/tracing/specializeType.trace @@ -1,3 +1,3 @@ B0($1:ptr) - CALL $2 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/sumArray.trace b/nautilus/test/data/pointer-tests/tracing/sumArray.trace index 0ab53b01..3eee3006 100644 --- a/nautilus/test/data/pointer-tests/tracing/sumArray.trace +++ b/nautilus/test/data/pointer-tests/tracing/sumArray.trace @@ -21,7 +21,7 @@ B1() ASSIGN $4 $20 :i32 JMP $0 B3() :void B2() - RETURN $3 :i32 + RETURN $0 $3 :i32 B3() ControlFlowMerge LT $5 $4 $2 :bool CMP $6 $5 B1() B2() :void diff --git a/nautilus/test/data/pointer-tests/tracing/useWrapper.trace b/nautilus/test/data/pointer-tests/tracing/useWrapper.trace index c3652e46..8f7ee0e1 100644 --- a/nautilus/test/data/pointer-tests/tracing/useWrapper.trace +++ b/nautilus/test/data/pointer-tests/tracing/useWrapper.trace @@ -1,5 +1,5 @@ B0($1:ptr,$2:ptr) - CALL $3 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($1) :i32 - CALL $4 nautilus::val::getX()::'lambda'(nautilus::CustomStruct2*)::__invoke(nautilus::CustomStruct2*)($2) :i32 + CALL $3 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($1) :i32 + CALL $4 _ZZN8nautilus3valIPNS_13CustomStruct2EE4getXEvENUlS2_E_8__invokeES2_($2) :i32 ADD $5 $3 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/callSameFunction.trace b/nautilus/test/data/runtime-call-tests/after_ssa/callSameFunction.trace index 93298929..a8595da4 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/callSameFunction.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/callSameFunction.trace @@ -1,4 +1,4 @@ B0($1:i32) - CALL $2 nautilus::engine::add(int, int)($1,$1) :i32 - CALL $3 nautilus::engine::add(int, int)($2,$2) :i32 - RETURN $3 :i32 + CALL $2 _ZN8nautilus6engine3addEii($1,$1) :i32 + CALL $3 _ZN8nautilus6engine3addEii($2,$2) :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/callTwoFunctions.trace b/nautilus/test/data/runtime-call-tests/after_ssa/callTwoFunctions.trace index 6375fc86..dc38890b 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/callTwoFunctions.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/callTwoFunctions.trace @@ -1,5 +1,5 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::add(int, int)($1,$2) :i32 - CALL $4 nautilus::engine::sub(int, int)($1,$2) :i32 + CALL $3 _ZN8nautilus6engine3addEii($1,$2) :i32 + CALL $4 _ZN8nautilus6engine3subEii($1,$2) :i32 ADD $5 $3 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/lambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/after_ssa/lambdaRuntimeFunction.trace index 761efef8..64d59281 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/lambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/lambdaRuntimeFunction.trace @@ -1,3 +1,3 @@ B0($1:i32) - CALL $2 nautilus::engine::lambdaRuntimeFunction(nautilus::val)::$_2::__invoke(int)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus6engine21lambdaRuntimeFunctionENS_3valIiEEEN3$_28__invokeEi($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/loopDirectCall.trace b/nautilus/test/data/runtime-call-tests/after_ssa/loopDirectCall.trace index 86ff7f43..bc9d8e28 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/loopDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/loopDirectCall.trace @@ -3,12 +3,12 @@ B0($1:i32,$2:i32) CONST $4 0 :i32 JMP $0 B3($3,$4,$1,$2) :void B1($1:i32,$4:i32,$3:i32,$2:i32) - CALL $7 nautilus::engine::add(int, int)($3,$2) :i32 + CALL $7 _ZN8nautilus6engine3addEii($3,$2) :i32 CONST $8 1 :i32 ADD $9 $4 $8 :i32 JMP $0 B3($7,$9,$1,$2) :void B2($3:i32) - RETURN $3 :i32 + RETURN $0 $3 :i32 B3($3:i32,$4:i32,$1:i32,$2:i32) ControlFlowMerge LT $5 $4 $1 :bool CMP $6 $5 B1($1,$4,$3,$2) B2($3) :void diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/nestedLambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/after_ssa/nestedLambdaRuntimeFunction.trace index 747ab3c9..ae788cab 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/nestedLambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/nestedLambdaRuntimeFunction.trace @@ -1,4 +1,4 @@ B0($1:i32) - CALL $2 nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_4::__invoke(int)($1) :i32 - CALL $3 nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_3::__invoke(int)($2) :i32 - RETURN $3 :i32 + CALL $2 _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_48__invokeEi($1) :i32 + CALL $3 _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_38__invokeEi($2) :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/simpleDirectCall.trace b/nautilus/test/data/runtime-call-tests/after_ssa/simpleDirectCall.trace index 21a4e635..d1c2306c 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/simpleDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/simpleDirectCall.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::add(int, int)($1,$2) :i32 - RETURN $3 :i32 + CALL $3 _ZN8nautilus6engine3addEii($1,$2) :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/useFirstArg.trace b/nautilus/test/data/runtime-call-tests/after_ssa/useFirstArg.trace index 7e63305d..d0a2aa96 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/useFirstArg.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/useFirstArg.trace @@ -1,2 +1,2 @@ B0($1:i32,$2:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/useNoArg.trace b/nautilus/test/data/runtime-call-tests/after_ssa/useNoArg.trace index 174daabd..3911764f 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/useNoArg.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/useNoArg.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) CONST $3 42 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/useSecondArg.trace b/nautilus/test/data/runtime-call-tests/after_ssa/useSecondArg.trace index c7654ec0..c0324d97 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/useSecondArg.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/useSecondArg.trace @@ -1,2 +1,2 @@ B0($1:i32,$2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/runtime-call-tests/after_ssa/voidFuncCall.trace b/nautilus/test/data/runtime-call-tests/after_ssa/voidFuncCall.trace index ccc1cb59..8a3b3ff8 100644 --- a/nautilus/test/data/runtime-call-tests/after_ssa/voidFuncCall.trace +++ b/nautilus/test/data/runtime-call-tests/after_ssa/voidFuncCall.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::voidFunc(int, int)($1,$2) :void - RETURN $1 :i32 + CALL $3 _ZN8nautilus6engine8voidFuncEii($1,$2) :void + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/runtime-call-tests/ir/callSameFunction.trace b/nautilus/test/data/runtime-call-tests/ir/callSameFunction.trace index a920a430..05e675d2 100644 --- a/nautilus/test/data/runtime-call-tests/ir/callSameFunction.trace +++ b/nautilus/test/data/runtime-call-tests/ir/callSameFunction.trace @@ -1,8 +1,8 @@ NautilusIr { execute() { Block_0($1:i32): - $2 = nautilus::engine::add(int, int)($1,$1) :i32 - $3 = nautilus::engine::add(int, int)($2,$2) :i32 + $2 = _ZN8nautilus6engine3addEii($1,$1) :i32 + $3 = _ZN8nautilus6engine3addEii($2,$2) :i32 return ($3) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/runtime-call-tests/ir/callTwoFunctions.trace b/nautilus/test/data/runtime-call-tests/ir/callTwoFunctions.trace index e0488501..a371101e 100644 --- a/nautilus/test/data/runtime-call-tests/ir/callTwoFunctions.trace +++ b/nautilus/test/data/runtime-call-tests/ir/callTwoFunctions.trace @@ -1,8 +1,8 @@ NautilusIr { execute() { Block_0($1:i32, $2:i32): - $3 = nautilus::engine::add(int, int)($1,$2) :i32 - $4 = nautilus::engine::sub(int, int)($1,$2) :i32 + $3 = _ZN8nautilus6engine3addEii($1,$2) :i32 + $4 = _ZN8nautilus6engine3subEii($1,$2) :i32 $5 = $3 + $4 :i32 return ($5) :i32 } diff --git a/nautilus/test/data/runtime-call-tests/ir/lambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/ir/lambdaRuntimeFunction.trace index f17052b7..0f0859fc 100644 --- a/nautilus/test/data/runtime-call-tests/ir/lambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/ir/lambdaRuntimeFunction.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:i32): - $2 = nautilus::engine::lambdaRuntimeFunction(nautilus::val)::$_2::__invoke(int)($1) :i32 + $2 = _ZZN8nautilus6engine21lambdaRuntimeFunctionENS_3valIiEEEN3$_28__invokeEi($1) :i32 return ($2) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/runtime-call-tests/ir/loopDirectCall.trace b/nautilus/test/data/runtime-call-tests/ir/loopDirectCall.trace index 13620515..2017d7c2 100644 --- a/nautilus/test/data/runtime-call-tests/ir/loopDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/ir/loopDirectCall.trace @@ -10,7 +10,7 @@ Block_3($3:i32, $4:i32, $1:i32, $2:i32): if $5 ? Block_1($1, $4, $3, $2) : Block_2($3) :void Block_1($1:i32, $4:i32, $3:i32, $2:i32): - $7 = nautilus::engine::add(int, int)($3,$2) :i32 + $7 = _ZN8nautilus6engine3addEii($3,$2) :i32 $8 = 1 :i32 $9 = $4 + $8 :i32 br Block_3($7, $9, $1, $2) :void diff --git a/nautilus/test/data/runtime-call-tests/ir/nestedLambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/ir/nestedLambdaRuntimeFunction.trace index 54d6516c..3badd1a4 100644 --- a/nautilus/test/data/runtime-call-tests/ir/nestedLambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/ir/nestedLambdaRuntimeFunction.trace @@ -1,8 +1,8 @@ NautilusIr { execute() { Block_0($1:i32): - $2 = nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_4::__invoke(int)($1) :i32 - $3 = nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_3::__invoke(int)($2) :i32 + $2 = _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_48__invokeEi($1) :i32 + $3 = _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_38__invokeEi($2) :i32 return ($3) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/runtime-call-tests/ir/simpleDirectCall.trace b/nautilus/test/data/runtime-call-tests/ir/simpleDirectCall.trace index d492b4da..ae6d1b2b 100644 --- a/nautilus/test/data/runtime-call-tests/ir/simpleDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/ir/simpleDirectCall.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:i32, $2:i32): - $3 = nautilus::engine::add(int, int)($1,$2) :i32 + $3 = _ZN8nautilus6engine3addEii($1,$2) :i32 return ($3) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/runtime-call-tests/ir/voidFuncCall.trace b/nautilus/test/data/runtime-call-tests/ir/voidFuncCall.trace index 002b6aa4..042d12fb 100644 --- a/nautilus/test/data/runtime-call-tests/ir/voidFuncCall.trace +++ b/nautilus/test/data/runtime-call-tests/ir/voidFuncCall.trace @@ -1,7 +1,7 @@ NautilusIr { execute() { Block_0($1:i32, $2:i32): - nautilus::engine::voidFunc(int, int)($1,$2) :void + _ZN8nautilus6engine8voidFuncEii($1,$2) :void return ($1) :i32 } } //NESIR \ No newline at end of file diff --git a/nautilus/test/data/runtime-call-tests/tracing/callSameFunction.trace b/nautilus/test/data/runtime-call-tests/tracing/callSameFunction.trace index 3030b034..9c51eda0 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/callSameFunction.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/callSameFunction.trace @@ -1,6 +1,6 @@ B0($1:i32) - CALL $2 nautilus::engine::add(int, int)($1,$1) :i32 + CALL $2 _ZN8nautilus6engine3addEii($1,$1) :i32 ASSIGN $1 $2 :i32 - CALL $3 nautilus::engine::add(int, int)($1,$1) :i32 + CALL $3 _ZN8nautilus6engine3addEii($1,$1) :i32 ASSIGN $1 $3 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/callTwoFunctions.trace b/nautilus/test/data/runtime-call-tests/tracing/callTwoFunctions.trace index 6375fc86..dc38890b 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/callTwoFunctions.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/callTwoFunctions.trace @@ -1,5 +1,5 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::add(int, int)($1,$2) :i32 - CALL $4 nautilus::engine::sub(int, int)($1,$2) :i32 + CALL $3 _ZN8nautilus6engine3addEii($1,$2) :i32 + CALL $4 _ZN8nautilus6engine3subEii($1,$2) :i32 ADD $5 $3 $4 :i32 - RETURN $5 :i32 + RETURN $0 $5 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/lambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/tracing/lambdaRuntimeFunction.trace index 761efef8..64d59281 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/lambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/lambdaRuntimeFunction.trace @@ -1,3 +1,3 @@ B0($1:i32) - CALL $2 nautilus::engine::lambdaRuntimeFunction(nautilus::val)::$_2::__invoke(int)($1) :i32 - RETURN $2 :i32 + CALL $2 _ZZN8nautilus6engine21lambdaRuntimeFunctionENS_3valIiEEEN3$_28__invokeEi($1) :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/loopDirectCall.trace b/nautilus/test/data/runtime-call-tests/tracing/loopDirectCall.trace index 950c3948..fb8b4cb5 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/loopDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/loopDirectCall.trace @@ -3,14 +3,14 @@ B0($1:i32,$2:i32) CONST $4 0 :i32 JMP $0 B3() :void B1() - CALL $7 nautilus::engine::add(int, int)($3,$2) :i32 + CALL $7 _ZN8nautilus6engine3addEii($3,$2) :i32 ASSIGN $3 $7 :i32 CONST $8 1 :i32 ADD $9 $4 $8 :i32 ASSIGN $4 $9 :i32 JMP $0 B3() :void B2() - RETURN $3 :i32 + RETURN $0 $3 :i32 B3() ControlFlowMerge LT $5 $4 $1 :bool CMP $6 $5 B1() B2() :void diff --git a/nautilus/test/data/runtime-call-tests/tracing/nestedLambdaRuntimeFunction.trace b/nautilus/test/data/runtime-call-tests/tracing/nestedLambdaRuntimeFunction.trace index 747ab3c9..ae788cab 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/nestedLambdaRuntimeFunction.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/nestedLambdaRuntimeFunction.trace @@ -1,4 +1,4 @@ B0($1:i32) - CALL $2 nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_4::__invoke(int)($1) :i32 - CALL $3 nautilus::engine::nestedLambdaRuntimeFunction(nautilus::val)::$_3::__invoke(int)($2) :i32 - RETURN $3 :i32 + CALL $2 _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_48__invokeEi($1) :i32 + CALL $3 _ZZN8nautilus6engine27nestedLambdaRuntimeFunctionENS_3valIiEEEN3$_38__invokeEi($2) :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/simpleDirectCall.trace b/nautilus/test/data/runtime-call-tests/tracing/simpleDirectCall.trace index 21a4e635..d1c2306c 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/simpleDirectCall.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/simpleDirectCall.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::add(int, int)($1,$2) :i32 - RETURN $3 :i32 + CALL $3 _ZN8nautilus6engine3addEii($1,$2) :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/useFirstArg.trace b/nautilus/test/data/runtime-call-tests/tracing/useFirstArg.trace index 7e63305d..d0a2aa96 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/useFirstArg.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/useFirstArg.trace @@ -1,2 +1,2 @@ B0($1:i32,$2:i32) - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/useNoArg.trace b/nautilus/test/data/runtime-call-tests/tracing/useNoArg.trace index 174daabd..3911764f 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/useNoArg.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/useNoArg.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) CONST $3 42 :i32 - RETURN $3 :i32 + RETURN $0 $3 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/useSecondArg.trace b/nautilus/test/data/runtime-call-tests/tracing/useSecondArg.trace index c7654ec0..c0324d97 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/useSecondArg.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/useSecondArg.trace @@ -1,2 +1,2 @@ B0($1:i32,$2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/runtime-call-tests/tracing/voidFuncCall.trace b/nautilus/test/data/runtime-call-tests/tracing/voidFuncCall.trace index ccc1cb59..8a3b3ff8 100644 --- a/nautilus/test/data/runtime-call-tests/tracing/voidFuncCall.trace +++ b/nautilus/test/data/runtime-call-tests/tracing/voidFuncCall.trace @@ -1,3 +1,3 @@ B0($1:i32,$2:i32) - CALL $3 nautilus::engine::voidFunc(int, int)($1,$2) :void - RETURN $1 :i32 + CALL $3 _ZN8nautilus6engine8voidFuncEii($1,$2) :void + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/static-loop-tests/after_ssa/staticConstIterator.trace b/nautilus/test/data/static-loop-tests/after_ssa/staticConstIterator.trace index 97140ca0..b790f3c7 100644 --- a/nautilus/test/data/static-loop-tests/after_ssa/staticConstIterator.trace +++ b/nautilus/test/data/static-loop-tests/after_ssa/staticConstIterator.trace @@ -54,4 +54,4 @@ B14($2:i32,$1:i32,$23:i32) ControlFlowMerge GT $24 $1 $23 :bool CMP $25 $24 B9($2) B10($2) :void B15($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/static-loop-tests/after_ssa/staticIterator.trace b/nautilus/test/data/static-loop-tests/after_ssa/staticIterator.trace index 97140ca0..b790f3c7 100644 --- a/nautilus/test/data/static-loop-tests/after_ssa/staticIterator.trace +++ b/nautilus/test/data/static-loop-tests/after_ssa/staticIterator.trace @@ -54,4 +54,4 @@ B14($2:i32,$1:i32,$23:i32) ControlFlowMerge GT $24 $1 $23 :bool CMP $25 $24 B9($2) B10($2) :void B15($2:i32) - RETURN $2 :i32 + RETURN $0 $2 :i32 diff --git a/nautilus/test/data/static-loop-tests/after_ssa/staticLoop.trace b/nautilus/test/data/static-loop-tests/after_ssa/staticLoop.trace index 6199edda..387aab6a 100644 --- a/nautilus/test/data/static-loop-tests/after_ssa/staticLoop.trace +++ b/nautilus/test/data/static-loop-tests/after_ssa/staticLoop.trace @@ -20,4 +20,4 @@ B0() ADD $19 $17 $18 :i32 CONST $20 10 :i32 ADD $21 $19 $20 :i32 - RETURN $21 :i32 + RETURN $0 $21 :i32 diff --git a/nautilus/test/data/static-loop-tests/after_ssa/staticLoopIncrement.trace b/nautilus/test/data/static-loop-tests/after_ssa/staticLoopIncrement.trace index 6199edda..387aab6a 100644 --- a/nautilus/test/data/static-loop-tests/after_ssa/staticLoopIncrement.trace +++ b/nautilus/test/data/static-loop-tests/after_ssa/staticLoopIncrement.trace @@ -20,4 +20,4 @@ B0() ADD $19 $17 $18 :i32 CONST $20 10 :i32 ADD $21 $19 $20 :i32 - RETURN $21 :i32 + RETURN $0 $21 :i32 diff --git a/nautilus/test/data/static-loop-tests/after_ssa/staticWhileLoopDecrement.trace b/nautilus/test/data/static-loop-tests/after_ssa/staticWhileLoopDecrement.trace index 5d59381d..9b11e9f2 100644 --- a/nautilus/test/data/static-loop-tests/after_ssa/staticWhileLoopDecrement.trace +++ b/nautilus/test/data/static-loop-tests/after_ssa/staticWhileLoopDecrement.trace @@ -22,4 +22,4 @@ B0() ADD $21 $19 $20 :i32 CONST $22 0 :i32 ADD $23 $21 $22 :i32 - RETURN $23 :i32 + RETURN $0 $23 :i32 diff --git a/nautilus/test/data/static-loop-tests/tracing/staticConstIterator.trace b/nautilus/test/data/static-loop-tests/tracing/staticConstIterator.trace index 51e14ac3..e78b1a26 100644 --- a/nautilus/test/data/static-loop-tests/tracing/staticConstIterator.trace +++ b/nautilus/test/data/static-loop-tests/tracing/staticConstIterator.trace @@ -47,9 +47,9 @@ B9() CONST $26 1 :i32 ADD $27 $2 $26 :i32 ASSIGN $2 $27 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B10() - RETURN $2 :i32 + RETURN $0 $2 :i32 B11() ControlFlowMerge GT $9 $1 $8 :bool CMP $10 $9 B3() B4() :void diff --git a/nautilus/test/data/static-loop-tests/tracing/staticIterator.trace b/nautilus/test/data/static-loop-tests/tracing/staticIterator.trace index 51e14ac3..e78b1a26 100644 --- a/nautilus/test/data/static-loop-tests/tracing/staticIterator.trace +++ b/nautilus/test/data/static-loop-tests/tracing/staticIterator.trace @@ -47,9 +47,9 @@ B9() CONST $26 1 :i32 ADD $27 $2 $26 :i32 ASSIGN $2 $27 :i32 - RETURN $2 :i32 + RETURN $0 $2 :i32 B10() - RETURN $2 :i32 + RETURN $0 $2 :i32 B11() ControlFlowMerge GT $9 $1 $8 :bool CMP $10 $9 B3() B4() :void diff --git a/nautilus/test/data/static-loop-tests/tracing/staticLoop.trace b/nautilus/test/data/static-loop-tests/tracing/staticLoop.trace index cc2255ac..bf7698f4 100644 --- a/nautilus/test/data/static-loop-tests/tracing/staticLoop.trace +++ b/nautilus/test/data/static-loop-tests/tracing/staticLoop.trace @@ -30,4 +30,4 @@ B0() CONST $20 10 :i32 ADD $21 $1 $20 :i32 ASSIGN $1 $21 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/static-loop-tests/tracing/staticLoopIncrement.trace b/nautilus/test/data/static-loop-tests/tracing/staticLoopIncrement.trace index cc2255ac..bf7698f4 100644 --- a/nautilus/test/data/static-loop-tests/tracing/staticLoopIncrement.trace +++ b/nautilus/test/data/static-loop-tests/tracing/staticLoopIncrement.trace @@ -30,4 +30,4 @@ B0() CONST $20 10 :i32 ADD $21 $1 $20 :i32 ASSIGN $1 $21 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/data/static-loop-tests/tracing/staticWhileLoopDecrement.trace b/nautilus/test/data/static-loop-tests/tracing/staticWhileLoopDecrement.trace index 5081e19c..2ba5d277 100644 --- a/nautilus/test/data/static-loop-tests/tracing/staticWhileLoopDecrement.trace +++ b/nautilus/test/data/static-loop-tests/tracing/staticWhileLoopDecrement.trace @@ -33,4 +33,4 @@ B0() CONST $22 0 :i32 ADD $23 $1 $22 :i32 ASSIGN $1 $23 :i32 - RETURN $1 :i32 + RETURN $0 $1 :i32 diff --git a/nautilus/test/execution-tests/ExecutionTest.cpp b/nautilus/test/execution-tests/ExecutionTest.cpp index 9cb7a037..b7815ad3 100644 --- a/nautilus/test/execution-tests/ExecutionTest.cpp +++ b/nautilus/test/execution-tests/ExecutionTest.cpp @@ -927,7 +927,8 @@ void registerFunctionTest(engine::NautilusEngine& engine) { SECTION("functionBindMember2") { auto clazz = Clazz(); clazz.state = 100; - std::function(val)> bound = std::bind(&Clazz::functionWithStateAccess, &clazz, std::placeholders::_1); + std::function(val)> bound = + std::bind(&Clazz::functionWithStateAccess, &clazz, std::placeholders::_1); auto f = engine.registerFunction(bound); REQUIRE(f(42) == 142); REQUIRE(f(1) == 101); diff --git a/nautilus/test/execution-tests/TracingTest.cpp b/nautilus/test/execution-tests/TracingTest.cpp index cc95b102..60677528 100644 --- a/nautilus/test/execution-tests/TracingTest.cpp +++ b/nautilus/test/execution-tests/TracingTest.cpp @@ -30,7 +30,7 @@ std::function createFunctionWrapper(std::index_sequence, R ( auto traceFunc = [=]() { if constexpr (std::is_void_v) { fnptr(details::createTraceableArgument()...); - tracing::traceReturnOperation(Type::v, tracing::value_ref()); + tracing::traceReturnOperation(Type::v, tracing::TypedValueRef()); } else { auto returnValue = fnptr(details::createTraceableArgument()...); auto type = tracing::to_type(); @@ -192,39 +192,40 @@ TEST_CASE("Expression Trace Test") { runTraceTests("expression-tests", tests); } TEST_CASE("Control-flow Trace Test") { - auto tests = std::vector>> {{"ifThenCondition", details::createFunctionWrapper(ifThenCondition)}, - {"multipleVoidReturnsFunction", details::createFunctionWrapper(multipleVoidReturnsFunction)}, - //{"conditionalReturn", details::createFunctionWrapper(conditionalReturn)}, - //{"multipleReturns", details::createFunctionWrapper(multipleReturns)}, - {"ifThenElseCondition", details::createFunctionWrapper(ifThenElseCondition)}, - {"nestedIfThenElseCondition", details::createFunctionWrapper(nestedIfThenElseCondition)}, - {"nestedIfNoElseCondition", details::createFunctionWrapper(nestedIfNoElseCondition)}, - {"doubleIfCondition", details::createFunctionWrapper(doubleIfCondition)}, - {"ifElseIfCondition", details::createFunctionWrapper(ifElseIfCondition)}, - {"orCondition", details::createFunctionWrapper(orCondition)}, - {"andCondition", details::createFunctionWrapper(andCondition)}, - {"deeplyNestedIfElseCondition", details::createFunctionWrapper(deeplyNestedIfElseCondition)}, - {"deeplyNestedIfElseIfCondition", details::createFunctionWrapper(deeplyNestedIfElseIfCondition)}, - {"andFunction", details::createFunctionWrapper(andFunction)}, - {"nestedIf", details::createFunctionWrapper(nestedIf)}, - {"ifElseIfElse", details::createFunctionWrapper(ifElseIfElse)}, - {"logicalAnd", details::createFunctionWrapper(logicalAnd)}, - {"logicalOr", details::createFunctionWrapper(logicalOr)}, - {"ifNotEqual", details::createFunctionWrapper(ifNotEqual)}, - {"multipleConditions", details::createFunctionWrapper(multipleConditions)}, - {"ifElseIfOnly", details::createFunctionWrapper(ifElseIfOnly)}, - {"compoundAssignment", details::createFunctionWrapper(compoundAssignment)}, - {"multipleElse", details::createFunctionWrapper(multipleElse)}, - {"ifWithTernary", details::createFunctionWrapper(ifWithTernary)}, - {"complexLogicalExpressions", details::createFunctionWrapper(complexLogicalExpressions)}, - {"shortCircuitEvaluation", details::createFunctionWrapper(shortCircuitEvaluation)}, - {"ifWithFunctionCall", details::createFunctionWrapper(ifWithFunctionCall)}, - {"compoundStatements", details::createFunctionWrapper(compoundStatements)}, - {"varyingComplexity", details::createFunctionWrapper(varyingComplexity)}, - {"logicalXOR", details::createFunctionWrapper(logicalXOR)}, - {"nestedIfElseDifferentLevels", details::createFunctionWrapper(nestedIfElseDifferentLevels)}, - {"constructComplexReturnObject", details::createFunctionWrapper(constructComplexReturnObject)}, - {"constructComplexReturnObject2", details::createFunctionWrapper(constructComplexReturnObject2)} + auto tests = std::vector>> { + {"ifThenCondition", details::createFunctionWrapper(ifThenCondition)}, + {"multipleVoidReturnsFunction", details::createFunctionWrapper(multipleVoidReturnsFunction)}, + //{"conditionalReturn", details::createFunctionWrapper(conditionalReturn)}, + //{"multipleReturns", details::createFunctionWrapper(multipleReturns)}, + {"ifThenElseCondition", details::createFunctionWrapper(ifThenElseCondition)}, + {"nestedIfThenElseCondition", details::createFunctionWrapper(nestedIfThenElseCondition)}, + {"nestedIfNoElseCondition", details::createFunctionWrapper(nestedIfNoElseCondition)}, + {"doubleIfCondition", details::createFunctionWrapper(doubleIfCondition)}, + {"ifElseIfCondition", details::createFunctionWrapper(ifElseIfCondition)}, + {"orCondition", details::createFunctionWrapper(orCondition)}, + {"andCondition", details::createFunctionWrapper(andCondition)}, + {"deeplyNestedIfElseCondition", details::createFunctionWrapper(deeplyNestedIfElseCondition)}, + {"deeplyNestedIfElseIfCondition", details::createFunctionWrapper(deeplyNestedIfElseIfCondition)}, + {"andFunction", details::createFunctionWrapper(andFunction)}, + {"nestedIf", details::createFunctionWrapper(nestedIf)}, + {"ifElseIfElse", details::createFunctionWrapper(ifElseIfElse)}, + {"logicalAnd", details::createFunctionWrapper(logicalAnd)}, + {"logicalOr", details::createFunctionWrapper(logicalOr)}, + {"ifNotEqual", details::createFunctionWrapper(ifNotEqual)}, + {"multipleConditions", details::createFunctionWrapper(multipleConditions)}, + {"ifElseIfOnly", details::createFunctionWrapper(ifElseIfOnly)}, + {"compoundAssignment", details::createFunctionWrapper(compoundAssignment)}, + {"multipleElse", details::createFunctionWrapper(multipleElse)}, + {"ifWithTernary", details::createFunctionWrapper(ifWithTernary)}, + {"complexLogicalExpressions", details::createFunctionWrapper(complexLogicalExpressions)}, + {"shortCircuitEvaluation", details::createFunctionWrapper(shortCircuitEvaluation)}, + {"ifWithFunctionCall", details::createFunctionWrapper(ifWithFunctionCall)}, + {"compoundStatements", details::createFunctionWrapper(compoundStatements)}, + {"varyingComplexity", details::createFunctionWrapper(varyingComplexity)}, + {"logicalXOR", details::createFunctionWrapper(logicalXOR)}, + {"nestedIfElseDifferentLevels", details::createFunctionWrapper(nestedIfElseDifferentLevels)}, + {"constructComplexReturnObject", details::createFunctionWrapper(constructComplexReturnObject)}, + {"constructComplexReturnObject2", details::createFunctionWrapper(constructComplexReturnObject2)} }; runTraceTests("control-flow-tests", tests); @@ -257,16 +258,17 @@ TEST_CASE("Loop Trace Test") { } TEST_CASE("Runtime Call Trace Test") { - auto tests = std::vector>> {{"simpleDirectCall", details::createFunctionWrapper(simpleDirectCall)}, - {"loopDirectCall", details::createFunctionWrapper(loopDirectCall)}, - {"useFirstArg", details::createFunctionWrapper(useFirstArg)}, - {"useSecondArg", details::createFunctionWrapper(useSecondArg)}, - {"useNoArg", details::createFunctionWrapper(useNoArg)}, - {"lambdaRuntimeFunction", details::createFunctionWrapper(lambdaRuntimeFunction)}, - {"nestedLambdaRuntimeFunction", details::createFunctionWrapper(nestedLambdaRuntimeFunction)}, - {"callSameFunction", details::createFunctionWrapper(callSameFunction)}, - {"voidFuncCall", details::createFunctionWrapper(voidFuncCall)}, - {"callTwoFunctions", details::createFunctionWrapper(callTwoFunctions)}}; + auto tests = std::vector>> { + {"simpleDirectCall", details::createFunctionWrapper(simpleDirectCall)}, + {"loopDirectCall", details::createFunctionWrapper(loopDirectCall)}, + {"useFirstArg", details::createFunctionWrapper(useFirstArg)}, + {"useSecondArg", details::createFunctionWrapper(useSecondArg)}, + {"useNoArg", details::createFunctionWrapper(useNoArg)}, + {"lambdaRuntimeFunction", details::createFunctionWrapper(lambdaRuntimeFunction)}, + {"nestedLambdaRuntimeFunction", details::createFunctionWrapper(nestedLambdaRuntimeFunction)}, + {"callSameFunction", details::createFunctionWrapper(callSameFunction)}, + {"voidFuncCall", details::createFunctionWrapper(voidFuncCall)}, + {"callTwoFunctions", details::createFunctionWrapper(callTwoFunctions)}}; runTraceTests("runtime-call-tests", tests); } @@ -299,15 +301,16 @@ TEST_CASE("Bool Trace Test") { } TEST_CASE("Static Trace Test") { - auto tests = std::vector>> {{"staticLoop", details::createFunctionWrapper(staticLoop)}, - // this test is sensitive to compiler options - //{"staticLoopWithIf", details::createFunctionWrapper(staticLoopWithIf)}, - //{"staticLoopWithDynamicLoop", - // details::createFunctionWrapper(staticLoopWithDynamicLoop)}, - {"staticIterator", details::createFunctionWrapper(staticIterator)}, - {"staticConstIterator", details::createFunctionWrapper(staticConstIterator)}, - {"staticLoopIncrement", details::createFunctionWrapper(staticLoopIncrement)}, - {"staticWhileLoopDecrement", details::createFunctionWrapper(staticWhileLoopDecrement)}}; + auto tests = std::vector>> { + {"staticLoop", details::createFunctionWrapper(staticLoop)}, + // this test is sensitive to compiler options + //{"staticLoopWithIf", details::createFunctionWrapper(staticLoopWithIf)}, + //{"staticLoopWithDynamicLoop", + // details::createFunctionWrapper(staticLoopWithDynamicLoop)}, + {"staticIterator", details::createFunctionWrapper(staticIterator)}, + {"staticConstIterator", details::createFunctionWrapper(staticConstIterator)}, + {"staticLoopIncrement", details::createFunctionWrapper(staticLoopIncrement)}, + {"staticWhileLoopDecrement", details::createFunctionWrapper(staticWhileLoopDecrement)}}; runTraceTests("static-loop-tests", tests); } diff --git a/nautilus/test/val-tests/IntegerValTypeTest.cpp b/nautilus/test/val-tests/IntegerValTypeTest.cpp index 3974e672..4525ea51 100644 --- a/nautilus/test/val-tests/IntegerValTypeTest.cpp +++ b/nautilus/test/val-tests/IntegerValTypeTest.cpp @@ -5,7 +5,8 @@ namespace nautilus { -TEMPLATE_TEST_CASE("Integer Val Operation Test", "[value][template]", int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t) { +TEMPLATE_TEST_CASE("Integer Val Operation Test", "[value][template]", int8_t, int16_t, int32_t, int64_t, uint8_t, + uint16_t, uint32_t, uint64_t) { SECTION("comparison operators") { SECTION("==") { auto f1 = val(static_cast(42)); diff --git a/nautilus/test/val-tests/ValConceptTest.cpp b/nautilus/test/val-tests/ValConceptTest.cpp index 921ceeef..46d4e577 100644 --- a/nautilus/test/val-tests/ValConceptTest.cpp +++ b/nautilus/test/val-tests/ValConceptTest.cpp @@ -15,7 +15,8 @@ bool defineOperator() { } } -TEMPLATE_TEST_CASE("Val Concept Test", "[value][template]", int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, uint32_t, uint64_t, size_t, float, double) { +TEMPLATE_TEST_CASE("Val Concept Test", "[value][template]", int8_t, int16_t, int32_t, int64_t, uint8_t, uint16_t, + uint32_t, uint64_t, size_t, float, double) { SECTION("convertible_to_fundamental") { REQUIRE(convertible_to_fundamental); REQUIRE(convertible_to_fundamental); diff --git a/third_party/backward-cpp/backward.hpp b/third_party/backward-cpp/backward.hpp index 670aa458..797eab1b 100644 --- a/third_party/backward-cpp/backward.hpp +++ b/third_party/backward-cpp/backward.hpp @@ -2925,7 +2925,7 @@ class TraceResolverLinuxImpl case DW_TAG_restrict_type: context.text.insert(0, "restrict "); break; - case DW_TAG_rvalue_reference_type: + case DW_TAG_rTypedValueReference_type: context.text.insert(0, "&&"); break; case DW_TAG_volatile_type: