From 9b6d21233dc4c4d54fd4c440d01b8120513774d9 Mon Sep 17 00:00:00 2001 From: Philipp Grulich Date: Thu, 19 Sep 2024 19:05:47 +0200 Subject: [PATCH] cleanup tracing util and remove unnecessary templates. (#44) --- nautilus/include/nautilus/common/Types.hpp | 106 ------ nautilus/include/nautilus/common/traceing.hpp | 142 -------- nautilus/include/nautilus/static.hpp | 2 +- nautilus/include/nautilus/std/ostream.h | 6 +- .../include/nautilus/tracing/Operations.hpp | 113 ++++++ .../include/nautilus/tracing/TracingUtil.hpp | 49 +++ .../{common => tracing}/TypedValueRef.hpp | 4 +- nautilus/include/nautilus/tracing/Types.hpp | 166 +++++++++ nautilus/include/nautilus/val.hpp | 26 +- nautilus/include/nautilus/val_concepts.hpp | 3 - nautilus/include/nautilus/val_enum.hpp | 2 +- nautilus/include/nautilus/val_ptr.hpp | 61 ++-- .../nautilus/common/TypedValueRefHolder.cpp | 2 +- .../compiler/backends/bc/ByteCode.hpp | 2 +- .../compiler/ir/operations/Operation.hpp | 2 +- nautilus/src/nautilus/tracing/Block.cpp | 4 +- nautilus/src/nautilus/tracing/Block.hpp | 2 +- .../src/nautilus/tracing/TraceContext.cpp | 22 +- .../src/nautilus/tracing/TraceContext.hpp | 22 +- .../src/nautilus/tracing/TraceOperation.cpp | 37 +- .../src/nautilus/tracing/TraceOperation.hpp | 4 +- nautilus/src/nautilus/tracing/TracingUtil.cpp | 329 +----------------- .../phases/TraceToIRConversionPhase.cpp | 55 +-- .../data/bool-tests/after_ssa/boolConst.trace | 2 +- .../bool-tests/after_ssa/boolIfElse.trace | 4 +- .../after_ssa/boolNestedFunction.trace | 4 +- .../data/bool-tests/tracing/boolConst.trace | 2 +- .../data/bool-tests/tracing/boolIfElse.trace | 4 +- .../tracing/boolNestedFunction.trace | 4 +- .../after_ssa/andFunction.trace | 2 +- .../after_ssa/conditionalReturn.trace | 12 - .../after_ssa/multipleReturns.trace | 21 -- .../ir/conditionalReturn.trace | 19 - .../ir/multipleReturns.trace | 30 -- .../tracing/andFunction.trace | 2 +- .../tracing/conditionalReturn.trace | 10 - .../tracing/multipleReturns.trace | 19 - .../test/data/enum-tests/tracing/isEnum.trace | 6 +- .../data/loop-tests/after_ssa/isPrime.trace | 4 +- .../data/loop-tests/tracing/isPrime.trace | 4 +- .../after_ssa/isNullptr_i8.trace | 2 +- .../pointer-tests/after_ssa/loadConst.trace | 2 +- .../pointer-tests/tracing/isNullptr_i8.trace | 2 +- .../pointer-tests/tracing/loadConst.trace | 2 +- 44 files changed, 484 insertions(+), 834 deletions(-) delete mode 100644 nautilus/include/nautilus/common/Types.hpp delete mode 100644 nautilus/include/nautilus/common/traceing.hpp create mode 100644 nautilus/include/nautilus/tracing/Operations.hpp create mode 100644 nautilus/include/nautilus/tracing/TracingUtil.hpp rename nautilus/include/nautilus/{common => tracing}/TypedValueRef.hpp (94%) create mode 100644 nautilus/include/nautilus/tracing/Types.hpp delete mode 100644 nautilus/test/data/control-flow-tests/after_ssa/conditionalReturn.trace delete mode 100644 nautilus/test/data/control-flow-tests/after_ssa/multipleReturns.trace delete mode 100644 nautilus/test/data/control-flow-tests/ir/conditionalReturn.trace delete mode 100644 nautilus/test/data/control-flow-tests/ir/multipleReturns.trace delete mode 100644 nautilus/test/data/control-flow-tests/tracing/conditionalReturn.trace delete mode 100644 nautilus/test/data/control-flow-tests/tracing/multipleReturns.trace diff --git a/nautilus/include/nautilus/common/Types.hpp b/nautilus/include/nautilus/common/Types.hpp deleted file mode 100644 index 4e6e2144..00000000 --- a/nautilus/include/nautilus/common/Types.hpp +++ /dev/null @@ -1,106 +0,0 @@ -#pragma once - -#include -#include - -namespace nautilus { - -enum class Type : uint8_t { v, b, i8, i16, i32, i64, ui8, ui16, ui32, ui64, f32, f64, ptr }; - -constexpr const char* toString(Type type) { - switch (type) { - case Type::v: - return "void"; - case Type::b: - return "bool"; - case Type::i8: - return "i8"; - case Type::i16: - return "i16"; - case Type::i32: - return "i32"; - case Type::i64: - return "i64"; - case Type::ui8: - return "ui8"; - case Type::ui16: - return "ui16"; - case Type::ui32: - return "ui32"; - case Type::ui64: - return "ui64"; - case Type::f32: - return "f32"; - case Type::f64: - return "f64"; - case Type::ptr: - return "ptr"; - default: - __builtin_unreachable(); - } -} - -constexpr bool isSignedInteger(Type type) { - switch (type) { - case Type::i8: - case Type::i16: - case Type::i32: - case Type::i64: - return true; - default: - return false; - } -} - -constexpr bool isUnsignedInteger(Type type) { - switch (type) { - case Type::ui8: - case Type::ui16: - case Type::ui32: - case Type::ui64: - return true; - default: - return false; - } -} - -constexpr bool isInteger(Type type) { - return isSignedInteger(type) || isUnsignedInteger(type); -} - -constexpr bool isFloat(Type type) { - switch (type) { - case Type::f32: - case Type::f64: - return true; - default: - return false; - } -} - -constexpr int8_t getBitWith(Type type) { - switch (type) { - case Type::v: - return -1; - case Type::b: - case Type::i8: - case Type::ui8: - return 8; - case Type::i16: - case Type::ui16: - return 16; - case Type::i32: - case Type::ui32: - case Type::f32: - return 32; - case Type::i64: - case Type::ui64: - case Type::f64: - case Type::ptr: - return 64; - } - return -1; -} - -std::ostream& operator<<(std::ostream& os, const Type& type); -} // namespace nautilus diff --git a/nautilus/include/nautilus/common/traceing.hpp b/nautilus/include/nautilus/common/traceing.hpp deleted file mode 100644 index 3dcd43d6..00000000 --- a/nautilus/include/nautilus/common/traceing.hpp +++ /dev/null @@ -1,142 +0,0 @@ - -#pragma once - -#include "nautilus/common/TypedValueRef.hpp" -#include "nautilus/common/Types.hpp" -#include "nautilus/val_concepts.hpp" -#include -#include -#include -#include -#include - -namespace nautilus::tracing { - -std::string getFunctionName(void* fnptr); - -enum Op : uint8_t { - JMP, - CMP, - RETURN, - ASSIGN, - CONST, - CAST, - FREE, - CALL, - // Memory - LOAD, - STORE, - // Logical - EQ, - NEQ, - LT, - LTE, - GT, - GTE, - NOT, - AND, - OR, - // Arithmetic - ADD, - MUL, - DIV, - SUB, - MOD, - // Binary - LSH, - RSH, - BOR, - BXOR, - BAND, - NEGATE, -}; - -template -constexpr Type to_type(); - -/** - * Returns the nautilus type for a C++ type. - * @tparam T - * @return Type - */ -template -constexpr Type to_type() { - using type = std::remove_cvref_t; - if constexpr (std::is_same_v) { - return Type::b; - } else if constexpr (std::is_same_v || (std::is_same_v) ) { - return Type::i8; - } else if constexpr (std::is_same_v) { - return Type::i16; - } else if constexpr (std::is_same_v) { - return Type::i32; - } else if constexpr (std::is_same_v) { - return Type::i64; - } else if constexpr (std::is_same_v) { - return Type::ui8; - } else if constexpr (std::is_same_v) { - return Type::ui16; - } else if constexpr (std::is_same_v) { - return Type::ui32; - } else if constexpr (std::is_same_v || std::is_same_v) { - return Type::ui64; - } else if constexpr (std::is_same_v) { - return Type::f32; - } else if constexpr (std::is_same_v) { - return Type::f64; - } else if constexpr (std::is_pointer_v) { - return Type::ptr; - } else { - return Type::v; - } -} - -[[maybe_unused, nodiscard]] bool inTracer(); - -[[maybe_unused]] value_ref traceBinaryOp(Op operation, Type resultType, value_ref leftState, value_ref rightState); - -template -[[maybe_unused]] value_ref traceBinaryOp(value_ref leftState, value_ref rightState) { - auto type = to_type(); - return traceBinaryOp(op, type, leftState, rightState); -} - -template -[[maybe_unused]] value_ref traceUnaryOp(value_ref inputState); - -[[maybe_unused]] bool traceBool(value_ref state); - -[[maybe_unused]] void traceStore(value_ref target, value_ref src, Type valueType); - -[[maybe_unused]] value_ref traceLoad(value_ref src, Type resultType); - -[[maybe_unused]] value_ref traceCopy(value_ref state); - -value_ref registerFunctionArgument(Type type, size_t index); - -void traceAssignment(value_ref target, value_ref source, Type resultType); - -value_ref traceConstant(Type type, std::any&& value); - -template -value_ref traceConstant(T value) { - if (!inTracer()) - return {0, to_type()}; - return traceConstant(to_type(), std::any(value)); -} - -void traceReturnOperation(Type type, value_ref ref); - -void traceValueDestruction(value_ref ref); - -value_ref traceCast(value_ref state, Type resultType); - -value_ref traceCall(void* fptn, Type resultType, const std::vector& arguments); - -std::ostream& operator<<(std::ostream& os, const Op& operation); - -void pushStaticVal(void* ptr); -void popStaticVal(); -void allocateValRef(ValueRef ref); -void freeValRef(ValueRef ref); -} // namespace nautilus::tracing diff --git a/nautilus/include/nautilus/static.hpp b/nautilus/include/nautilus/static.hpp index 5323904c..e912cc58 100644 --- a/nautilus/include/nautilus/static.hpp +++ b/nautilus/include/nautilus/static.hpp @@ -1,6 +1,6 @@ #pragma once -#include "nautilus/common/traceing.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #include #include #include diff --git a/nautilus/include/nautilus/std/ostream.h b/nautilus/include/nautilus/std/ostream.h index ee7e4ae5..7940a868 100644 --- a/nautilus/include/nautilus/std/ostream.h +++ b/nautilus/include/nautilus/std/ostream.h @@ -1,9 +1,9 @@ #pragma once -#include "nautilus/val_ptr.hpp" -#include "nautilus/val.hpp" #include "nautilus/std/string.h" -#include +#include "nautilus/val.hpp" +#include "nautilus/val_ptr.hpp" #include +#include namespace nautilus { template diff --git a/nautilus/include/nautilus/tracing/Operations.hpp b/nautilus/include/nautilus/tracing/Operations.hpp new file mode 100644 index 00000000..0f5e3e72 --- /dev/null +++ b/nautilus/include/nautilus/tracing/Operations.hpp @@ -0,0 +1,113 @@ +#pragma once + +#include "nautilus/val_concepts.hpp" +#include +#include + +namespace nautilus::tracing { + +enum Op : uint8_t { + JMP, + CMP, + RETURN, + ASSIGN, + CONST, + CAST, + FREE, + CALL, + // Memory + LOAD, + STORE, + // Logical + EQ, + NEQ, + LT, + LTE, + GT, + GTE, + NOT, + AND, + OR, + // Arithmetic + ADD, + MUL, + DIV, + SUB, + MOD, + // Binary + LSH, + RSH, + BOR, + BXOR, + BAND, + NEGATE, +}; + +constexpr const char* toString(Op type) { + switch (type) { + case FREE: + return "FREE"; + case CAST: + return "CAST"; + case CALL: + return "CALL"; + case LOAD: + return "LOAD"; + case STORE: + return "STORE"; + case JMP: + return "JMP"; + case CMP: + return "CMP"; + case RETURN: + return "RETURN"; + case ASSIGN: + return "ASSIGN"; + case CONST: + return "CONST"; + case EQ: + return "EQ"; + case NEQ: + return "NEQ"; + case LT: + return "LT"; + case LTE: + return "LTE"; + case GT: + return "GT"; + case GTE: + return "GTE"; + case NOT: + return "NOT"; + case AND: + return "AND"; + case OR: + return "OR"; + case ADD: + return "ADD"; + case MUL: + return "MUL"; + case DIV: + return "DIV"; + case SUB: + return "SUB"; + case MOD: + return "MOD"; + case LSH: + return "LSH"; + case RSH: + return "RSH"; + case BOR: + return "BOR"; + case BAND: + return "BAND"; + case BXOR: + return "BXOR"; + case NEGATE: + return "NEGATE"; + default: + __builtin_unreachable(); + } +} + +} // namespace nautilus::tracing diff --git a/nautilus/include/nautilus/tracing/TracingUtil.hpp b/nautilus/include/nautilus/tracing/TracingUtil.hpp new file mode 100644 index 00000000..7880f4e0 --- /dev/null +++ b/nautilus/include/nautilus/tracing/TracingUtil.hpp @@ -0,0 +1,49 @@ + +#pragma once + +#include "nautilus/tracing/Operations.hpp" +#include "nautilus/tracing/TypedValueRef.hpp" +#include "nautilus/tracing/Types.hpp" +#include "nautilus/val_concepts.hpp" +#include +#include +#include +#include +#include + +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); + +bool traceBool(const TypedValueRef& state); +value_ref traceConstant(Type type, const ConstantLiteral& value); +template +value_ref 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); + +value_ref traceCall(void* fptn, Type resultType, const std::vector& arguments); + +value_ref registerFunctionArgument(Type type, size_t index); + +void traceReturnOperation(Type type, const value_ref& ref); +void traceValueDestruction(value_ref ref); + +void pushStaticVal(void* ptr); +void popStaticVal(); +void allocateValRef(ValueRef ref); +void freeValRef(ValueRef ref); +} // namespace nautilus::tracing diff --git a/nautilus/include/nautilus/common/TypedValueRef.hpp b/nautilus/include/nautilus/tracing/TypedValueRef.hpp similarity index 94% rename from nautilus/include/nautilus/common/TypedValueRef.hpp rename to nautilus/include/nautilus/tracing/TypedValueRef.hpp index 4ba85e81..a0e31d17 100644 --- a/nautilus/include/nautilus/common/TypedValueRef.hpp +++ b/nautilus/include/nautilus/tracing/TypedValueRef.hpp @@ -1,7 +1,7 @@ #pragma once -#include "nautilus/common/Types.hpp" +#include "nautilus/tracing/Types.hpp" namespace nautilus::tracing { using ValueRef = uint16_t; @@ -52,4 +52,4 @@ class TypedValueRefHolder { }; using value_ref = TypedValueRef; -} // namespace nautilus::tracing \ No newline at end of file +} // namespace nautilus::tracing diff --git a/nautilus/include/nautilus/tracing/Types.hpp b/nautilus/include/nautilus/tracing/Types.hpp new file mode 100644 index 00000000..a3717dc9 --- /dev/null +++ b/nautilus/include/nautilus/tracing/Types.hpp @@ -0,0 +1,166 @@ +#pragma once + +#include "nautilus/val_concepts.hpp" +#include +#include +#include + +namespace nautilus { + +enum class Type : uint8_t { v, b, i8, i16, i32, i64, ui8, ui16, ui32, ui64, f32, f64, ptr }; + +using ConstantLiteral = std::variant; + +namespace tracing { + +template +concept is_compatible_val_type = is_ptr || is_fundamental || is_fundamental_ref || is_bool || is_bool_ref; + +template + requires is_ptr> +constexpr ConstantLiteral createConstLiteral(T&& t) noexcept { + return ConstantLiteral((void*) t); +} + +template + requires is_fundamental> || is_bool> +constexpr ConstantLiteral createConstLiteral(T&& t) noexcept { + return ConstantLiteral(t); +} + +/** + * Returns the nautilus type for a C++ type. + * @tparam T + * @return Type + */ +template +constexpr Type to_type() { + using type = std::remove_cvref_t; + if constexpr (std::is_same_v) { + return Type::b; + } else if constexpr (std::is_same_v || (std::is_same_v) ) { + return Type::i8; + } else if constexpr (std::is_same_v) { + return Type::i16; + } else if constexpr (std::is_same_v) { + return Type::i32; + } else if constexpr (std::is_same_v) { + return Type::i64; + } else if constexpr (std::is_same_v) { + return Type::ui8; + } else if constexpr (std::is_same_v) { + return Type::ui16; + } else if constexpr (std::is_same_v) { + return Type::ui32; + } else if constexpr (std::is_same_v || std::is_same_v) { + return Type::ui64; + } else if constexpr (std::is_same_v) { + return Type::f32; + } else if constexpr (std::is_same_v) { + return Type::f64; + } else if constexpr (std::is_pointer_v) { + return Type::ptr; + } else { + return Type::v; + } +} +} // namespace tracing + +constexpr const char* toString(Type type) { + switch (type) { + case Type::v: + return "void"; + case Type::b: + return "bool"; + case Type::i8: + return "i8"; + case Type::i16: + return "i16"; + case Type::i32: + return "i32"; + case Type::i64: + return "i64"; + case Type::ui8: + return "ui8"; + case Type::ui16: + return "ui16"; + case Type::ui32: + return "ui32"; + case Type::ui64: + return "ui64"; + case Type::f32: + return "f32"; + case Type::f64: + return "f64"; + case Type::ptr: + return "ptr"; + default: + __builtin_unreachable(); + } +} + +constexpr bool isSignedInteger(Type type) { + switch (type) { + case Type::i8: + case Type::i16: + case Type::i32: + case Type::i64: + return true; + default: + return false; + } +} + +constexpr bool isUnsignedInteger(Type type) { + switch (type) { + case Type::ui8: + case Type::ui16: + case Type::ui32: + case Type::ui64: + return true; + default: + return false; + } +} + +constexpr bool isInteger(Type type) { + return isSignedInteger(type) || isUnsignedInteger(type); +} + +constexpr bool isFloat(Type type) { + switch (type) { + case Type::f32: + case Type::f64: + return true; + default: + return false; + } +} + +constexpr int8_t getBitWith(Type type) { + switch (type) { + case Type::v: + return -1; + case Type::b: + case Type::i8: + case Type::ui8: + return 8; + case Type::i16: + case Type::ui16: + return 16; + case Type::i32: + case Type::ui32: + case Type::f32: + return 32; + case Type::i64: + case Type::ui64: + case Type::f64: + case Type::ptr: + return 64; + } + return -1; +} + +std::ostream& operator<<(std::ostream& os, const Type& type); + +} // namespace nautilus diff --git a/nautilus/include/nautilus/val.hpp b/nautilus/include/nautilus/val.hpp index 1f1f8bc4..c2bf5334 100644 --- a/nautilus/include/nautilus/val.hpp +++ b/nautilus/include/nautilus/val.hpp @@ -7,7 +7,7 @@ #ifdef ENABLE_TRACING -#include "common/traceing.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #endif @@ -248,7 +248,7 @@ namespace details { auto&& rValue = cast_value(std::forward(right)); \ using resultType = decltype(getRawValue(lValue) OP getRawValue(rValue)); \ if SHOULD_TRACE () { \ - auto tc = tracing::traceBinaryOp(details::getState(lValue), details::getState(rValue)); \ + 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)); \ @@ -290,7 +290,7 @@ template val neg(val& val) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = traceUnaryOp(val.state); + auto tc = tracing::traceUnaryOp(tracing::NEGATE, tracing::to_type(), val.state); return tc; } #endif @@ -308,21 +308,21 @@ LHS inline getRawValue(const val& val) { template \ requires(CON_VAL && CON_VAL) \ auto inline operator OP(LHS&& left, RHS&& right) { \ - return details::FUNC(std::move(left), std::move(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)); \ + 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)); \ + 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) @@ -431,7 +431,7 @@ namespace details { val inline lOr(val& left, val& right) { #ifdef ENABLE_TRACING if SHOULD_TRACE () { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::OR, tracing::to_type(), left.state, right.state); return val {tc}; } #endif @@ -441,7 +441,7 @@ val inline lOr(val& left, val& right) { val inline lAnd(val& left, val& right) { #ifdef ENABLE_TRACING if SHOULD_TRACE () { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::AND, tracing::to_type(), left.state, right.state); return val {tc}; } #endif @@ -451,7 +451,7 @@ val inline lAnd(val& left, val& right) { val inline lNot(val& arg) { #ifdef ENABLE_TRACING if SHOULD_TRACE () { - auto tc = tracing::traceUnaryOp(arg.state); + auto tc = tracing::traceUnaryOp(tracing::NOT, Type::b, arg.state); return val {tc}; } #endif diff --git a/nautilus/include/nautilus/val_concepts.hpp b/nautilus/include/nautilus/val_concepts.hpp index 66dea639..b987d600 100644 --- a/nautilus/include/nautilus/val_concepts.hpp +++ b/nautilus/include/nautilus/val_concepts.hpp @@ -98,7 +98,4 @@ concept is_traceable_value = requires(T a) { { a.state }; }; -template -concept is_compatible_val_type = is_ptr || is_fundamental || is_fundamental_ref || is_bool || is_bool_ref; - } // namespace nautilus diff --git a/nautilus/include/nautilus/val_enum.hpp b/nautilus/include/nautilus/val_enum.hpp index bc04f360..03cfdb25 100644 --- a/nautilus/include/nautilus/val_enum.hpp +++ b/nautilus/include/nautilus/val_enum.hpp @@ -6,7 +6,7 @@ #ifdef ENABLE_TRACING -#include "common/traceing.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #endif diff --git a/nautilus/include/nautilus/val_ptr.hpp b/nautilus/include/nautilus/val_ptr.hpp index 4074cb08..60179a40 100644 --- a/nautilus/include/nautilus/val_ptr.hpp +++ b/nautilus/include/nautilus/val_ptr.hpp @@ -1,8 +1,8 @@ #pragma once -#include #include "nautilus/val.hpp" +#include namespace nautilus { @@ -17,12 +17,17 @@ class val { const tracing::TypedValueRefHolder state; #endif #ifdef ENABLE_TRACING - val(ValueType ref) : state(tracing::value_ref()), ptr(&ref) {} - val(ValueType ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) {} - val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) {} + val(ValueType ref) : state(tracing::value_ref()), ptr(&ref) { + } + val(ValueType ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) { + } + val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) { + } #else - val(ValueType ref) : ptr(&ref) {} - val(val ptr) : ptr(ptr) {} + val(ValueType ref) : ptr(&ref) { + } + val(val ptr) : ptr(ptr) { + } #endif template @@ -80,16 +85,21 @@ class base_ptr_val { using basic_type = std::remove_pointer_t; using pointer_type = ValuePtrType; - base_ptr_val() : value() {} + base_ptr_val() : value() { + } #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::TypedValueRefHolder tc) : state(std::move(tc)), value(ptr) {} + 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::TypedValueRefHolder tc) : state(std::move(tc)), value(ptr) { + } base_ptr_val(tracing::value_ref ref) : state(ref), value(nullptr) { } #else - base_ptr_val(ValuePtrType ptr) : value(ptr) {} + base_ptr_val(ValuePtrType ptr) : value(ptr) { + } #endif #ifdef ENABLE_TRACING @@ -217,7 +227,7 @@ val inline operator+(val left, IndexType offset) { auto offsetBytes = offsetValue * size; #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, offsetBytes.state); + auto tc = tracing::traceBinaryOp(tracing::ADD, tracing::to_type(), left.state, offsetBytes.state); return val(tc); } #endif @@ -242,7 +252,7 @@ auto inline operator==(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::EQ, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -268,7 +278,7 @@ template auto inline operator<=(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::LTE, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -280,7 +290,7 @@ template auto inline operator<(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::LT, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -292,7 +302,7 @@ template auto inline operator>(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::GT, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -304,7 +314,7 @@ template auto inline operator>=(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::GTE, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -316,7 +326,7 @@ template auto inline operator!=(val left, val right) { #ifdef ENABLE_TRACING if (tracing::inTracer()) { - auto tc = tracing::traceBinaryOp(left.state, right.state); + auto tc = tracing::traceBinaryOp(tracing::NEQ, tracing::to_type(), left.state, right.state); return val(tc); } #endif @@ -346,12 +356,17 @@ class val { #ifdef ENABLE_TRACING tracing::TypedValueRefHolder state; - val(bool ref) : state(tracing::value_ref()), ptr(&ref) {} - val(bool& ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) {} - val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) {} + val(bool ref) : state(tracing::value_ref()), ptr(&ref) { + } + val(bool& ref, tracing::value_ref value_ref) : state(value_ref), ptr(&ref) { + } + val(val ptr, tracing::value_ref ref) : state(ref), ptr(ptr) { + } #else - val(bool ref) : ptr(&ref) {} - val(val ptr) : ptr(ptr) {} + val(bool ref) : ptr(&ref) { + } + val(val ptr) : ptr(ptr) { + } #endif template diff --git a/nautilus/src/nautilus/common/TypedValueRefHolder.cpp b/nautilus/src/nautilus/common/TypedValueRefHolder.cpp index f9dffb6e..e58176ee 100644 --- a/nautilus/src/nautilus/common/TypedValueRefHolder.cpp +++ b/nautilus/src/nautilus/common/TypedValueRefHolder.cpp @@ -1,5 +1,5 @@ -#include "nautilus/common/traceing.hpp" #include "nautilus/config.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #include namespace nautilus::tracing { diff --git a/nautilus/src/nautilus/compiler/backends/bc/ByteCode.hpp b/nautilus/src/nautilus/compiler/backends/bc/ByteCode.hpp index c8b50875..d120d1c0 100644 --- a/nautilus/src/nautilus/compiler/backends/bc/ByteCode.hpp +++ b/nautilus/src/nautilus/compiler/backends/bc/ByteCode.hpp @@ -1,6 +1,6 @@ #pragma once -#include "nautilus/common/Types.hpp" +#include "nautilus/tracing/Types.hpp" #include "nautilus/exceptions/NotImplementedException.hpp" #include #include diff --git a/nautilus/src/nautilus/compiler/ir/operations/Operation.hpp b/nautilus/src/nautilus/compiler/ir/operations/Operation.hpp index 12e5327c..a03aca20 100644 --- a/nautilus/src/nautilus/compiler/ir/operations/Operation.hpp +++ b/nautilus/src/nautilus/compiler/ir/operations/Operation.hpp @@ -1,7 +1,7 @@ #pragma once -#include "nautilus/common/Types.hpp" +#include "nautilus/tracing/Types.hpp" #include #include #include diff --git a/nautilus/src/nautilus/tracing/Block.cpp b/nautilus/src/nautilus/tracing/Block.cpp index c02fc560..0ab8a826 100644 --- a/nautilus/src/nautilus/tracing/Block.cpp +++ b/nautilus/src/nautilus/tracing/Block.cpp @@ -1,6 +1,6 @@ #include "nautilus/tracing/Block.hpp" -#include "nautilus/common/Types.hpp" -#include "nautilus/common/traceing.hpp" +#include "nautilus/tracing/TracingUtil.hpp" +#include "nautilus/tracing/Types.hpp" namespace nautilus::tracing { diff --git a/nautilus/src/nautilus/tracing/Block.hpp b/nautilus/src/nautilus/tracing/Block.hpp index 308a1873..3dc74b88 100644 --- a/nautilus/src/nautilus/tracing/Block.hpp +++ b/nautilus/src/nautilus/tracing/Block.hpp @@ -2,7 +2,7 @@ #pragma once #include "TraceOperation.hpp" -#include "nautilus/common/traceing.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #include #include #include diff --git a/nautilus/src/nautilus/tracing/TraceContext.cpp b/nautilus/src/nautilus/tracing/TraceContext.cpp index 4b977a32..88af1371 100644 --- a/nautilus/src/nautilus/tracing/TraceContext.cpp +++ b/nautilus/src/nautilus/tracing/TraceContext.cpp @@ -51,7 +51,7 @@ void TraceContext::traceValueDestruction(nautilus::tracing::value_ref) { return; } -value_ref TraceContext::traceLoad(value_ref src, Type resultType) { +value_ref TraceContext::traceLoad(const value_ref& src, Type resultType) { if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -68,7 +68,7 @@ value_ref TraceContext::traceLoad(value_ref src, Type resultType) { throw TraceTerminationException(); } -void TraceContext::traceStore(value_ref target, value_ref src, Type valueType) { +void TraceContext::traceStore(const value_ref& target, const value_ref& src, Type valueType) { if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -88,7 +88,7 @@ bool TraceContext::isFollowing() { return symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW; } -value_ref TraceContext::traceConstValue(Type type, std::any constValue) { +value_ref TraceContext::traceConstValue(Type type, const ConstantLiteral& constValue) { log::debug("Trace Constant"); if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); @@ -116,7 +116,7 @@ Tag* TraceContext::getTag() { return tagRecorder.createTag(); } -value_ref TraceContext::traceCopy(nautilus::tracing::value_ref ref) { +value_ref TraceContext::traceCopy(const value_ref& ref) { log::debug("Trace Copy"); if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { auto currentOperation = executionTrace->getCurrentOperation(); @@ -133,7 +133,7 @@ value_ref TraceContext::traceCopy(nautilus::tracing::value_ref ref) { throw TraceTerminationException(); } -value_ref TraceContext::traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, std::vector arguments) { +value_ref TraceContext::traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, const std::vector& arguments) { if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -157,7 +157,7 @@ value_ref TraceContext::traceCall(const std::string& functionName, const std::st throw TraceTerminationException(); } -void TraceContext::traceAssignment(value_ref targetRef, value_ref sourceRef, Type resultType) { +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(); @@ -182,7 +182,7 @@ void TraceContext::traceAssignment(value_ref targetRef, value_ref sourceRef, Typ throw TraceTerminationException(); } -value_ref TraceContext::traceCast(value_ref state, Type resultType) { +value_ref TraceContext::traceCast(const value_ref& state, Type resultType) { if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -204,7 +204,7 @@ value_ref TraceContext::traceCast(value_ref state, Type resultType) { throw TraceTerminationException(); } -void TraceContext::traceReturnOperation(Type type, value_ref ref) { +void TraceContext::traceReturnOperation(Type type, const value_ref& ref) { if (symbolicExecutionContext->getCurrentMode() == SymbolicExecutionContext::MODE::FOLLOW) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -215,7 +215,7 @@ void TraceContext::traceReturnOperation(Type type, value_ref ref) { executionTrace->addReturn(tag, type, ref); } -value_ref TraceContext::traceUnaryOperation(nautilus::tracing::Op op, Type resultType, nautilus::tracing::value_ref& inputRef) { +value_ref TraceContext::traceUnaryOperation(nautilus::tracing::Op op, Type resultType, const value_ref& inputRef) { if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -232,7 +232,7 @@ value_ref TraceContext::traceUnaryOperation(nautilus::tracing::Op op, Type resul throw TraceTerminationException(); } -value_ref TraceContext::traceBinaryOperation(Op op, Type resultType, value_ref& leftRef, value_ref& rightRef) { +value_ref TraceContext::traceBinaryOperation(Op op, Type resultType, const value_ref& leftRef, const value_ref& rightRef) { if (isFollowing()) { auto currentOperation = executionTrace->getCurrentOperation(); executionTrace->nextOperation(); @@ -251,7 +251,7 @@ value_ref TraceContext::traceBinaryOperation(Op op, Type resultType, value_ref& throw TraceTerminationException(); } -bool TraceContext::traceCmp(value_ref targetRef) { +bool TraceContext::traceCmp(const value_ref& 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 813c2ef9..55e63e35 100644 --- a/nautilus/src/nautilus/tracing/TraceContext.hpp +++ b/nautilus/src/nautilus/tracing/TraceContext.hpp @@ -49,9 +49,9 @@ class TraceContext { * @param valueReference reference to the const value. * @param constValue constant value. */ - value_ref traceConstValue(Type type, std::any constValue); + value_ref traceConstValue(Type type, const ConstantLiteral& constValue); - value_ref traceCopy(value_ref ref); + value_ref traceCopy(const value_ref& ref); Tag* getTag(); @@ -61,7 +61,7 @@ class TraceContext { * @param inputRef reference to the input. * @param resultRef reference to the result. */ - value_ref traceUnaryOperation(Op op, Type resultType, value_ref& inputRef); + value_ref traceUnaryOperation(Op op, Type resultType, const value_ref& inputRef); /** * @brief Trace a binary operation, e.g., add, sub, div. @@ -70,30 +70,30 @@ class TraceContext { * @param rightRef reference to the right input. * @param resultRef reference to the result. */ - value_ref traceBinaryOperation(Op op, Type resultType, value_ref& leftRef, value_ref& rightRef); + value_ref traceBinaryOperation(Op op, Type resultType, const value_ref& leftRef, const value_ref& rightRef); /** * @brief Trace the return function. * @param resultRef referent to the return value. */ - void traceReturnOperation(Type type, value_ref ref); + void traceReturnOperation(Type type, const value_ref& ref); /** * @brief Trace a value assignment. * @param targetRef reference to the target value. * @param sourceRef reference to the source value. */ - void traceAssignment(value_ref targetRef, value_ref sourceRef, Type resultType); + void traceAssignment(const value_ref& targetRef, const value_ref& sourceRef, Type resultType); - value_ref traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, std::vector arguments); + value_ref traceCall(const std::string& functionName, const std::string& mangledName, void* fptn, Type resultType, const std::vector& arguments); - bool traceCmp(value_ref targetRef); + bool traceCmp(const value_ref& targetRef); - value_ref traceLoad(value_ref src, Type resultType); + value_ref traceLoad(const value_ref& src, Type resultType); - value_ref traceCast(value_ref state, Type resultType); + value_ref traceCast(const value_ref& state, Type resultType); - void traceStore(value_ref target, value_ref src, Type valueType); + void traceStore(const value_ref& target, const value_ref& src, Type valueType); ~TraceContext() = default; diff --git a/nautilus/src/nautilus/tracing/TraceOperation.cpp b/nautilus/src/nautilus/tracing/TraceOperation.cpp index ab1f8eae..07d9e686 100644 --- a/nautilus/src/nautilus/tracing/TraceOperation.cpp +++ b/nautilus/src/nautilus/tracing/TraceOperation.cpp @@ -40,7 +40,7 @@ std::ostream& operator<<(std::ostream& os, const TraceOperation& operation) { if (operation.op == FREE) { return os; } - os << operation.op << "\t"; + os << fmt::format("{}\t", toString(operation.op)); os << operation.resultRef.toString() << "\t"; for (const InputVariant& opInput : operation.input) { if (auto inputRef = std::get_if(&opInput)) { @@ -49,30 +49,17 @@ std::ostream& operator<<(std::ostream& os, const TraceOperation& operation) { os << *blockRef << "\t"; } else if (auto fCall = std::get_if(&opInput)) { os << *fCall << "\t"; - } else if (auto constant = std::get_if(&opInput)) { - if (constant->type() == typeid(int8_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(int16_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(int32_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(int64_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(uint8_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(uint16_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(uint32_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(uint64_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(size_t)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(float)) { - os << any_cast(*constant) << "\t"; - } else if (constant->type() == typeid(double)) { - os << any_cast(*constant) << "\t"; - } + } else if (auto constant = std::get_if(&opInput)) { + std::visit( + [&](auto&& value) -> void { + using T = std::decay_t; + if constexpr (!std::is_pointer_v) { + os << value << "\t"; + } else { + os << "*\t"; + } + }, + *constant); } } os << fmt::format(":{}\t", toString(operation.resultType)); diff --git a/nautilus/src/nautilus/tracing/TraceOperation.hpp b/nautilus/src/nautilus/tracing/TraceOperation.hpp index 814c1253..645f75ff 100644 --- a/nautilus/src/nautilus/tracing/TraceOperation.hpp +++ b/nautilus/src/nautilus/tracing/TraceOperation.hpp @@ -1,8 +1,8 @@ #pragma once -#include "nautilus/common/traceing.hpp" #include "nautilus/tracing/Snapshot.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #include "nautilus/tracing/tag/Tag.hpp" #include #include @@ -34,7 +34,7 @@ struct BlockRef { friend std::ostream& operator<<(std::ostream& os, const BlockRef& ref); }; -using InputVariant = std::variant; +using InputVariant = std::variant; /** * @brief Represents an individual operation in a trace. diff --git a/nautilus/src/nautilus/tracing/TracingUtil.cpp b/nautilus/src/nautilus/tracing/TracingUtil.cpp index e1a6139e..dd4772e3 100644 --- a/nautilus/src/nautilus/tracing/TracingUtil.cpp +++ b/nautilus/src/nautilus/tracing/TracingUtil.cpp @@ -1,7 +1,6 @@ +#include "nautilus/tracing/TracingUtil.hpp" #include "TraceContext.hpp" -#include "nautilus/common/traceing.hpp" -#include "nautilus/logging.hpp" #include #include #include @@ -31,43 +30,39 @@ std::string getFunctionName(const std::string& mangledName) { return mangledName; } -void traceAssignment(value_ref target, value_ref source, Type resultType) { +void traceAssignment(const TypedValueRef& target, const TypedValueRef& source, Type resultType) { TraceContext::get()->traceAssignment(target, source, resultType); } -void traceValueDestruction(value_ref target) { +void traceValueDestruction(const TypedValueRef& target) { TraceContext::get()->traceValueDestruction(target); } -void traceReturnOperation(Type type, value_ref ref) { +void traceReturnOperation(Type type, const TypedValueRef& ref) { TraceContext::get()->traceReturnOperation(type, ref); } -Tag* getTag() { - return TraceContext::get()->getTag(); -} - value_ref registerFunctionArgument(Type type, size_t index) { return TraceContext::get()->registerFunctionArgument(type, index); } -[[maybe_unused]] value_ref traceLoad(value_ref src, Type resultType) { +value_ref traceLoad(const TypedValueRef& src, Type resultType) { return TraceContext::get()->traceLoad(src, resultType); } -[[maybe_unused]] void traceStore(value_ref target, value_ref src, Type valueType) { +void traceStore(const TypedValueRef& target, const TypedValueRef& src, Type valueType) { TraceContext::get()->traceStore(target, src, valueType); } -value_ref traceConstant(Type type, std::any&& value) { +value_ref traceConstant(Type type, const ConstantLiteral& value) { return TraceContext::get()->traceConstValue(type, value); } -[[maybe_unused]] bool traceBool(value_ref state) { +bool traceBool(const TypedValueRef& state) { return TraceContext::get()->traceCmp(state); } -[[maybe_unused]] value_ref traceCast(value_ref state, Type resultType) { +value_ref traceCast(const TypedValueRef& state, Type resultType) { return TraceContext::get()->traceCast(state, resultType); } @@ -78,14 +73,14 @@ void freeValRef(ValueRef ref) { TraceContext::get()->freeValRef(ref); } -[[maybe_unused]] value_ref traceCopy(value_ref state) { +value_ref traceCopy(const value_ref& state) { if (inTracer()) { return TraceContext::get()->traceCopy(state); } return {}; } -[[maybe_unused]] bool inTracer() { +bool inTracer() { return TraceContext::get() != nullptr; } @@ -95,310 +90,16 @@ value_ref traceCall(void* fptn, Type resultType, const std::vectortraceCall(functionName, mangledName, fptn, resultType, arguments); } -[[maybe_unused]] value_ref traceBinaryOp(Op operation, Type resultType, value_ref leftState, value_ref rightState) { +value_ref traceBinaryOp(Op operation, Type resultType, const TypedValueRef& leftState, const TypedValueRef& rightState) { return TraceContext::get()->traceBinaryOperation(operation, resultType, leftState, rightState); } -template -[[maybe_unused]] value_ref traceUnaryOp(value_ref leftState) { - auto type = to_type(); - return TraceContext::get()->traceUnaryOperation(op, type, leftState); +value_ref traceUnaryOp(Op operation, Type resultType, const TypedValueRef& inputState) { + return TraceContext::get()->traceUnaryOperation(operation, resultType, inputState); } -#if __APPLE__ -#define INSTANTIATE_TRACE_FUNC(OP) \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -#else -#define INSTANTIATE_TRACE_FUNC(OP) \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); \ - template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); -#endif - -#define INSTANTIATE_TRACE_UN_FUNC(OP) \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); \ - template value_ref traceUnaryOp(value_ref leftState); - -template value_ref traceUnaryOp(value_ref leftState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -template value_ref traceBinaryOp(value_ref leftState, value_ref rightState); - -INSTANTIATE_TRACE_FUNC(EQ) - -INSTANTIATE_TRACE_FUNC(NEQ) - -INSTANTIATE_TRACE_FUNC(LT) - -INSTANTIATE_TRACE_FUNC(LTE) - -INSTANTIATE_TRACE_FUNC(GT) - -INSTANTIATE_TRACE_FUNC(GTE) - -INSTANTIATE_TRACE_FUNC(AND) - -INSTANTIATE_TRACE_FUNC(OR) - -INSTANTIATE_TRACE_FUNC(ADD) - -INSTANTIATE_TRACE_FUNC(SUB) - -INSTANTIATE_TRACE_FUNC(DIV) - -INSTANTIATE_TRACE_FUNC(MUL) - -INSTANTIATE_TRACE_FUNC(MOD) - -INSTANTIATE_TRACE_FUNC(LSH) - -INSTANTIATE_TRACE_FUNC(RSH) - -INSTANTIATE_TRACE_FUNC(BOR) - -INSTANTIATE_TRACE_FUNC(BAND) - -INSTANTIATE_TRACE_UN_FUNC(NOT) - -template value_ref traceConstant(char value); - -template value_ref traceConstant(int8_t value); - -template value_ref traceConstant(int16_t value); - -template value_ref traceConstant(int32_t value); - -template value_ref traceConstant(int64_t value); - -template value_ref traceConstant(uint8_t value); - -template value_ref traceConstant(uint16_t value); - -template value_ref traceConstant(uint32_t value); - -template value_ref traceConstant(uint64_t value); - -#if __APPLE__ - -template value_ref traceConstant(size_t value); - -#endif - -template value_ref traceConstant(float value); - -template value_ref traceConstant(double value); - -template value_ref traceConstant(bool value); - -template value_ref traceConstant(char* value); - -template value_ref traceConstant(const char* value); - -// template value_ref traceConstant(char8_t* value); -template value_ref traceConstant(char16_t* value); - -template value_ref traceConstant(char32_t* value); - -template value_ref traceConstant(wchar_t* value); - -template value_ref traceConstant(int8_t* value); - -template value_ref traceConstant(int16_t* value); - -template value_ref traceConstant(int32_t* value); - -template value_ref traceConstant(int64_t* value); - -template value_ref traceConstant(uint8_t* value); - -template value_ref traceConstant(uint16_t* value); - -template value_ref traceConstant(uint32_t* value); - -template value_ref traceConstant(uint64_t* value); - -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); -template value_ref traceUnaryOp(value_ref leftState); - -#if __APPLE__ - -template value_ref traceConstant(size_t* value); - -#endif - std::ostream& operator<<(std::ostream& os, const Op& operation) { - switch (operation) { - case FREE: - os << "FREE"; - break; - case CAST: - os << "CAST"; - break; - case CALL: - os << "CALL"; - break; - case LOAD: - os << "LOAD"; - break; - case STORE: - os << "STORE"; - break; - case JMP: - os << "JMP"; - break; - case CMP: - os << "CMP"; - break; - case RETURN: - os << "RETURN"; - break; - case ASSIGN: - os << "ASSIGN"; - break; - case CONST: - os << "CONST"; - break; - case EQ: - os << "EQ"; - break; - case NEQ: - os << "NEQ"; - break; - case LT: - os << "LT"; - break; - case LTE: - os << "LTE"; - break; - case GT: - os << "GT"; - break; - case GTE: - os << "GTE"; - break; - case NOT: - os << "NOT"; - break; - case AND: - os << "AND"; - break; - case OR: - os << "OR"; - break; - case ADD: - os << "ADD"; - break; - case MUL: - os << "MUL"; - break; - case DIV: - os << "DIV"; - break; - case SUB: - os << "SUB"; - break; - case MOD: - os << "MOD"; - break; - case LSH: - os << "LSH"; - break; - case RSH: - os << "RSH"; - break; - case BOR: - os << "BOR"; - break; - case BAND: - os << "BAND"; - break; - case BXOR: - os << "BXOR"; - break; - case NEGATE: - os << "NEGATE"; - break; - } + os << toString(operation); return os; } diff --git a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp index 788dcef5..6e1f0610 100644 --- a/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp +++ b/nautilus/src/nautilus/tracing/phases/TraceToIRConversionPhase.cpp @@ -1,6 +1,5 @@ #include "nautilus/tracing/phases/TraceToIRConversionPhase.hpp" -#include "nautilus/common/traceing.hpp" #include "nautilus/compiler/ir/operations/ArithmeticOperations/DivOperation.hpp" #include "nautilus/compiler/ir/operations/ArithmeticOperations/ModOperation.hpp" #include "nautilus/compiler/ir/operations/ArithmeticOperations/MulOperation.hpp" @@ -17,6 +16,7 @@ #include "nautilus/compiler/ir/operations/ProxyCallOperation.hpp" #include "nautilus/compiler/ir/operations/StoreOperation.hpp" #include "nautilus/exceptions/NotImplementedException.hpp" +#include "nautilus/tracing/TracingUtil.hpp" #include #include @@ -435,44 +435,27 @@ bool TraceToIRConversionPhase::IRConversionContext::isBlockInLoop(uint32_t paren } void TraceToIRConversionPhase::IRConversionContext::processConst(int32_t, TraceToIRConversionPhase::ValueFrame& frame, BasicBlock* currentBlock, TraceOperation& operation) { - auto constant = &std::get(operation.input[0]); + auto constant = std::get(operation.input[0]); auto resultIdentifier = createValueIdentifier(operation.resultRef); auto resultType = (operation.resultType); Operation* constOperation; - if (constant->type() == typeid(int8_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(int16_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(int32_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(int64_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(uint8_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(uint16_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - - } else if (constant->type() == typeid(uint32_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - - } else if (constant->type() == typeid(uint64_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - } else if (constant->type() == typeid(size_t)) { - constOperation = currentBlock->addOperation(resultIdentifier, (uint64_t) any_cast(*constant), resultType); - - } else if (constant->type() == typeid(float)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - - } else if (constant->type() == typeid(double)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant), resultType); - - } else if (constant->type() == typeid(bool)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant)); - } else if (constant->type() == typeid(void*)) { - constOperation = currentBlock->addOperation(resultIdentifier, any_cast(*constant)); - } else { - throw NotImplementedException("Not constant implemented."); - } + + std::visit( + [&](auto&& value) { + using T = std::decay_t; + if constexpr (std::is_same_v) { + constOperation = currentBlock->addOperation(resultIdentifier, value); + } else if constexpr (std::is_integral_v) { + constOperation = currentBlock->addOperation(resultIdentifier, value, resultType); + } else if constexpr (std::is_floating_point_v) { + constOperation = currentBlock->addOperation(resultIdentifier, value, resultType); + } else if constexpr (std::is_pointer_v) { + constOperation = currentBlock->addOperation(resultIdentifier, value); + } else { + // static_assert(false, "non-exhaustive visitor!"); + } + }, + constant); frame.setValue(resultIdentifier, constOperation); } diff --git a/nautilus/test/data/bool-tests/after_ssa/boolConst.trace b/nautilus/test/data/bool-tests/after_ssa/boolConst.trace index 07eb4efd..a0ae7b7d 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 :bool + CONST $3 1 :bool AND $4 $1 $3 :bool RETURN $4 :bool diff --git a/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace b/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace index cf17f066..1f3f50af 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolIfElse.trace @@ -2,10 +2,10 @@ B0($1:bool,$2:bool) AND $5 $1 $2 :bool CMP $6 $5 B1() B2() :void B1() - CONST $7 :bool + CONST $7 1 :bool JMP $0 B3($7) :void B2() - CONST $10 :bool + CONST $10 0 :bool JMP $0 B3($10) :void B3($7:bool) RETURN $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 8171ecee..004f6a2e 100644 --- a/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace +++ b/nautilus/test/data/bool-tests/after_ssa/boolNestedFunction.trace @@ -2,10 +2,10 @@ B0($1:bool,$2:bool) EQ $5 $1 $2 :bool CMP $6 $5 B1() B2() :void B1() - CONST $7 :bool + CONST $7 1 :bool JMP $0 B3($7) :void B2() - CONST $10 :bool + CONST $10 0 :bool JMP $0 B3($10) :void B3($7:bool) RETURN $7 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolConst.trace b/nautilus/test/data/bool-tests/tracing/boolConst.trace index 3e0f7f42..e1011528 100644 --- a/nautilus/test/data/bool-tests/tracing/boolConst.trace +++ b/nautilus/test/data/bool-tests/tracing/boolConst.trace @@ -1,5 +1,5 @@ B0($1:bool) ASSIGN $2 $1 :bool - CONST $3 :bool + CONST $3 1 :bool AND $4 $2 $3 :bool RETURN $4 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolIfElse.trace b/nautilus/test/data/bool-tests/tracing/boolIfElse.trace index f8b7e7bd..0a329617 100644 --- a/nautilus/test/data/bool-tests/tracing/boolIfElse.trace +++ b/nautilus/test/data/bool-tests/tracing/boolIfElse.trace @@ -4,8 +4,8 @@ B0($1:bool,$2:bool) AND $5 $3 $4 :bool CMP $6 $5 B1() B2() :void B1() - CONST $7 :bool + CONST $7 1 :bool RETURN $7 :bool B2() - CONST $10 :bool + CONST $10 0 :bool RETURN $10 :bool diff --git a/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace b/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace index 25248fe7..931d9f57 100644 --- a/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace +++ b/nautilus/test/data/bool-tests/tracing/boolNestedFunction.trace @@ -4,8 +4,8 @@ B0($1:bool,$2:bool) EQ $5 $3 $4 :bool CMP $6 $5 B1() B2() :void B1() - CONST $7 :bool + CONST $7 1 :bool RETURN $7 :bool B2() - CONST $10 :bool + CONST $10 0 :bool RETURN $10 :bool 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 571bc06e..bb4b5199 100644 --- a/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace +++ b/nautilus/test/data/control-flow-tests/after_ssa/andFunction.trace @@ -1,5 +1,5 @@ B0($1:i32) - CONST $2 :bool + CONST $2 1 :bool CONST $4 42 :i64 CAST $5 $1 :i64 EQ $6 $5 $4 :bool diff --git a/nautilus/test/data/control-flow-tests/after_ssa/conditionalReturn.trace b/nautilus/test/data/control-flow-tests/after_ssa/conditionalReturn.trace deleted file mode 100644 index 092f9896..00000000 --- a/nautilus/test/data/control-flow-tests/after_ssa/conditionalReturn.trace +++ /dev/null @@ -1,12 +0,0 @@ -B0($1:i32) - CONST $2 42 :i32 - EQ $3 $1 $2 :bool - CMP $4 $3 B1() B2() :void -B1() - CONST $5 1 :i32 - JMP $0 B3($5) :void -B2() - CONST $7 120 :i32 - JMP $0 B3($7) :void -B3($5:i32) - RETURN $5 :i32 diff --git a/nautilus/test/data/control-flow-tests/after_ssa/multipleReturns.trace b/nautilus/test/data/control-flow-tests/after_ssa/multipleReturns.trace deleted file mode 100644 index f8511e7c..00000000 --- a/nautilus/test/data/control-flow-tests/after_ssa/multipleReturns.trace +++ /dev/null @@ -1,21 +0,0 @@ -B0($1:i32) - CONST $2 1 :i32 - EQ $3 $1 $2 :bool - CMP $4 $3 B1() B2($1) :void -B1() - CONST $5 1 :i32 - JMP $0 B5($5) :void -B2($1:i32) - CONST $7 10 :i32 - LT $8 $1 $7 :bool - CMP $9 $8 B3() B4($1) :void -B3() - CONST $10 42 :i32 - JMP $0 B5($10) :void -B4($1:i32) - ADD $12 $1 $1 :i32 - CONST $13 1 :i32 - ADD $14 $12 $13 :i32 - JMP $0 B5($14) :void -B5($5:i32) - RETURN $5 :i32 diff --git a/nautilus/test/data/control-flow-tests/ir/conditionalReturn.trace b/nautilus/test/data/control-flow-tests/ir/conditionalReturn.trace deleted file mode 100644 index db3aee6f..00000000 --- a/nautilus/test/data/control-flow-tests/ir/conditionalReturn.trace +++ /dev/null @@ -1,19 +0,0 @@ -NESIR { -execute() { -Block_0($1:i32): - $2 = 42 :i32 - $3 = $1 == $2 :bool - if $3 ? Block_1() : Block_2() :void - -Block_1(): - $5 = 1 :i32 - br Block_3($5) :void - -Block_3($5:i32): - return ($5) :i32 - -Block_2(): - $7 = 120 :i32 - br Block_3($7) :void -} -} //NESIR \ No newline at end of file diff --git a/nautilus/test/data/control-flow-tests/ir/multipleReturns.trace b/nautilus/test/data/control-flow-tests/ir/multipleReturns.trace deleted file mode 100644 index 3f72ca2a..00000000 --- a/nautilus/test/data/control-flow-tests/ir/multipleReturns.trace +++ /dev/null @@ -1,30 +0,0 @@ -NESIR { -execute() { -Block_0($1:i32): - $2 = 1 :i32 - $3 = $1 == $2 :bool - if $3 ? Block_1() : Block_2($1) :void - -Block_1(): - $5 = 1 :i32 - br Block_5($5) :void - -Block_5($5:i32): - return ($5) :i32 - -Block_2($1:i32): - $7 = 10 :i32 - $8 = $1 < $7 :bool - if $8 ? Block_3() : Block_4($1) :void - -Block_3(): - $10 = 42 :i32 - br Block_5($10) :void - -Block_4($1:i32): - $12 = $1 + $1 :i32 - $13 = 1 :i32 - $14 = $12 + $13 :i32 - br Block_5($14) :void -} -} //NESIR \ No newline at end of file diff --git a/nautilus/test/data/control-flow-tests/tracing/andFunction.trace b/nautilus/test/data/control-flow-tests/tracing/andFunction.trace index a7ad00c4..cb23ef1f 100644 --- a/nautilus/test/data/control-flow-tests/tracing/andFunction.trace +++ b/nautilus/test/data/control-flow-tests/tracing/andFunction.trace @@ -1,5 +1,5 @@ B0($1:i32) - CONST $2 :bool + CONST $2 1 :bool ASSIGN $3 $2 :bool CONST $4 42 :i64 CAST $5 $1 :i64 diff --git a/nautilus/test/data/control-flow-tests/tracing/conditionalReturn.trace b/nautilus/test/data/control-flow-tests/tracing/conditionalReturn.trace deleted file mode 100644 index 7475818e..00000000 --- a/nautilus/test/data/control-flow-tests/tracing/conditionalReturn.trace +++ /dev/null @@ -1,10 +0,0 @@ -B0($1:i32) - CONST $2 42 :i32 - EQ $3 $1 $2 :bool - CMP $4 $3 B1() B2() :void -B1() - CONST $5 1 :i32 - RETURN $5 :i32 -B2() - CONST $7 120 :i32 - RETURN $7 :i32 diff --git a/nautilus/test/data/control-flow-tests/tracing/multipleReturns.trace b/nautilus/test/data/control-flow-tests/tracing/multipleReturns.trace deleted file mode 100644 index 00abd539..00000000 --- a/nautilus/test/data/control-flow-tests/tracing/multipleReturns.trace +++ /dev/null @@ -1,19 +0,0 @@ -B0($1:i32) - CONST $2 1 :i32 - EQ $3 $1 $2 :bool - CMP $4 $3 B1() B2() :void -B1() - CONST $5 1 :i32 - RETURN $5 :i32 -B2() - CONST $7 10 :i32 - LT $8 $1 $7 :bool - CMP $9 $8 B3() B4() :void -B3() - CONST $10 42 :i32 - RETURN $10 :i32 -B4() - ADD $12 $1 $1 :i32 - CONST $13 1 :i32 - ADD $14 $12 $13 :i32 - RETURN $14 :i32 diff --git a/nautilus/test/data/enum-tests/tracing/isEnum.trace b/nautilus/test/data/enum-tests/tracing/isEnum.trace index 85e58f7c..72ebe93d 100644 --- a/nautilus/test/data/enum-tests/tracing/isEnum.trace +++ b/nautilus/test/data/enum-tests/tracing/isEnum.trace @@ -11,9 +11,7 @@ B2() CMP $9 $8 B3() B4() :void B3() CONST $10 2 :i32 - ASSIGN $5 $10 :i32 - RETURN $5 :i32 + RETURN $10 :i32 B4() CONST $12 42 :i32 - ASSIGN $5 $12 :i32 - RETURN $5 :i32 + RETURN $12 :i32 diff --git a/nautilus/test/data/loop-tests/after_ssa/isPrime.trace b/nautilus/test/data/loop-tests/after_ssa/isPrime.trace index 90dd4279..5f964047 100644 --- a/nautilus/test/data/loop-tests/after_ssa/isPrime.trace +++ b/nautilus/test/data/loop-tests/after_ssa/isPrime.trace @@ -1,6 +1,6 @@ B0($1:i32) - CONST $2 :bool - CONST $3 :bool + CONST $2 0 :bool + CONST $3 1 :bool CONST $4 1 :i32 LTE $5 $1 $4 :bool CMP $6 $5 B1($2) B2($2,$1,$3) :void diff --git a/nautilus/test/data/loop-tests/tracing/isPrime.trace b/nautilus/test/data/loop-tests/tracing/isPrime.trace index c68552ae..3270058c 100644 --- a/nautilus/test/data/loop-tests/tracing/isPrime.trace +++ b/nautilus/test/data/loop-tests/tracing/isPrime.trace @@ -1,6 +1,6 @@ B0($1:i32) - CONST $2 :bool - CONST $3 :bool + CONST $2 0 :bool + CONST $3 1 :bool CONST $4 1 :i32 LTE $5 $1 $4 :bool CMP $6 $5 B1() B2() :void 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 15fd3db3..042db741 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 + CONST $3 * :ptr EQ $6 $1 $3 :bool RETURN $6 :bool diff --git a/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace b/nautilus/test/data/pointer-tests/after_ssa/loadConst.trace index 9668d5a3..75dc7acf 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 + CONST $1 * :ptr LOAD $4 $1 :i32 RETURN $4 :i32 diff --git a/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace b/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace index e9c80f51..90a90b26 100644 --- a/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace +++ b/nautilus/test/data/pointer-tests/tracing/isNullptr_i8.trace @@ -1,6 +1,6 @@ B0($1:ptr) ASSIGN $2 $1 :ptr - CONST $3 :ptr + CONST $3 * :ptr ASSIGN $4 $2 :ptr ASSIGN $5 $3 :ptr EQ $6 $4 $5 :bool diff --git a/nautilus/test/data/pointer-tests/tracing/loadConst.trace b/nautilus/test/data/pointer-tests/tracing/loadConst.trace index d1f3978c..ef5f07a6 100644 --- a/nautilus/test/data/pointer-tests/tracing/loadConst.trace +++ b/nautilus/test/data/pointer-tests/tracing/loadConst.trace @@ -1,5 +1,5 @@ B0() - CONST $1 :ptr + CONST $1 * :ptr ASSIGN $2 $1 :ptr ASSIGN $3 $2 :ptr LOAD $4 $3 :i32