Merge pull request #632 from scratchcpp/address_sanitizer

adazem009 · web-flow · commit b255dc7977ef · 2025-02-26T10:07:21.000+01:00
Use address sanitizer in unit tests
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -10,6 +10,12 @@ option(LIBSCRATCHCPP_BUILD_UNIT_TESTS "Build unit tests" ON)
 option(LIBSCRATCHCPP_NETWORK_SUPPORT "Support for downloading projects" ON)
 option(LIBSCRATCHCPP_PRINT_LLVM_IR "Print LLVM IR of compiled Scratch scripts (for debugging)" OFF)
 
+if (CMAKE_BUILD_TYPE MATCHES "Debug")
+    set(SANITIZER_FLAGS "-fsanitize=undefined -fsanitize=address -fno-omit-frame-pointer")
+    set(CMAKE_CFLAGS ${CMAKE_CFLAGS} ${SANITIZER_FLAGS})
+    set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} ${SANITIZER_FLAGS})
+endif()
+
 add_library(scratchcpp SHARED)
 add_subdirectory(src)
 include_directories(src) # TODO: Remove this line
diff --git a/include/scratchcpp/compilerconstant.h b/include/scratchcpp/compilerconstant.h
@@ -10,7 +10,7 @@ namespace libscratchcpp
 class CompilerConstantPrivate;
 
 /*! \brief The CompilerConstant class represents a constant value in compiled code. */
-class LIBSCRATCHCPP_EXPORT CompilerConstant : public CompilerValue
+class LIBSCRATCHCPP_EXPORT CompilerConstant : public virtual CompilerValue
 {
     public:
         CompilerConstant(Compiler::StaticType type, const Value &value);
diff --git a/src/engine/internal/llvm/CMakeLists.txt b/src/engine/internal/llvm/CMakeLists.txt
@@ -2,7 +2,6 @@ target_sources(scratchcpp
   PRIVATE
     llvmcodebuilder.cpp
     llvmcodebuilder.h
-    llvmregisterbase.h
     llvmregister.h
     llvmconstantregister.h
     llvminstruction.h
diff --git a/src/engine/internal/llvm/llvmcodebuilder.cpp b/src/engine/internal/llvm/llvmcodebuilder.cpp
@@ -980,7 +980,7 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 llvm::Value *inRange = m_builder.CreateAnd(m_builder.CreateFCmpOGE(index, min), m_builder.CreateFCmpOLT(index, size));
 
                 LLVMConstantRegister nullReg(listPtr.type == Compiler::StaticType::Unknown ? Compiler::StaticType::Number : listPtr.type, Value());
-                llvm::Value *null = createValue(static_cast<LLVMRegister *>(static_cast<CompilerValue *>(&nullReg)));
+                llvm::Value *null = createValue(static_cast<LLVMRegister *>(&nullReg));
 
                 index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
                 step.functionReturnReg->value = m_builder.CreateSelect(inRange, getListItem(listPtr, index), null);
@@ -1378,7 +1378,7 @@ CompilerValue *LLVMCodeBuilder::addFunctionCall(const std::string &functionName,
     ins->functionName = functionName;
 
     for (size_t i = 0; i < args.size(); i++)
-        ins->args.push_back({ argTypes[i], static_cast<LLVMRegister *>(args[i]) });
+        ins->args.push_back({ argTypes[i], dynamic_cast<LLVMRegister *>(args[i]) });
 
     if (returnType != Compiler::StaticType::Void) {
         auto reg = std::make_shared<LLVMRegister>(returnType);
@@ -1409,9 +1409,9 @@ CompilerValue *LLVMCodeBuilder::addFunctionCallWithCtx(const std::string &functi
 CompilerConstant *LLVMCodeBuilder::addConstValue(const Value &value)
 {
     auto constReg = std::make_shared<LLVMConstantRegister>(TYPE_MAP[value.type()], value);
-    auto reg = std::reinterpret_pointer_cast<LLVMRegister>(constReg);
+    auto reg = std::static_pointer_cast<LLVMRegister>(constReg);
     m_lastConstValue = reg.get();
-    return static_cast<CompilerConstant *>(static_cast<CompilerValue *>(addReg(reg, nullptr)));
+    return static_cast<CompilerConstant *>(static_cast<LLVMConstantRegister *>(addReg(reg, nullptr)));
 }
 
 CompilerValue *LLVMCodeBuilder::addStringChar(CompilerValue *string, CompilerValue *index)
@@ -1470,7 +1470,7 @@ CompilerValue *LLVMCodeBuilder::addListItem(List *list, CompilerValue *index)
     if (m_listPtrs.find(list) == m_listPtrs.cend())
         m_listPtrs[list] = LLVMListPtr();
 
-    ins->args.push_back({ Compiler::StaticType::Number, static_cast<LLVMRegister *>(index) });
+    ins->args.push_back({ Compiler::StaticType::Number, dynamic_cast<LLVMRegister *>(index) });
 
     auto ret = std::make_shared<LLVMRegister>(Compiler::StaticType::Unknown);
     ret->isRawValue = false;
@@ -1807,7 +1807,7 @@ void LLVMCodeBuilder::createListReplace(List *list, CompilerValue *index, Compil
 void LLVMCodeBuilder::beginIfStatement(CompilerValue *cond)
 {
     auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::BeginIf, currentLoopScope(), m_loopCondition);
-    ins->args.push_back({ Compiler::StaticType::Bool, static_cast<LLVMRegister *>(cond) });
+    ins->args.push_back({ Compiler::StaticType::Bool, dynamic_cast<LLVMRegister *>(cond) });
     m_instructions.push_back(ins);
 }
 
@@ -1826,7 +1826,7 @@ void LLVMCodeBuilder::beginRepeatLoop(CompilerValue *count)
     assert(!m_loopCondition);
 
     auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::BeginRepeatLoop, currentLoopScope(), m_loopCondition);
-    ins->args.push_back({ Compiler::StaticType::Number, static_cast<LLVMRegister *>(count) });
+    ins->args.push_back({ Compiler::StaticType::Number, dynamic_cast<LLVMRegister *>(count) });
     m_instructions.push_back(ins);
     pushLoopScope(false);
 }
@@ -1837,7 +1837,7 @@ void LLVMCodeBuilder::beginWhileLoop(CompilerValue *cond)
     m_loopCondition = false;
 
     auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::BeginWhileLoop, currentLoopScope(), m_loopCondition);
-    ins->args.push_back({ Compiler::StaticType::Bool, static_cast<LLVMRegister *>(cond) });
+    ins->args.push_back({ Compiler::StaticType::Bool, dynamic_cast<LLVMRegister *>(cond) });
     m_instructions.push_back(ins);
     pushLoopScope(false);
 }
@@ -1848,7 +1848,7 @@ void LLVMCodeBuilder::beginRepeatUntilLoop(CompilerValue *cond)
     m_loopCondition = false;
 
     auto ins = std::make_shared<LLVMInstruction>(LLVMInstruction::Type::BeginRepeatUntilLoop, currentLoopScope(), m_loopCondition);
-    ins->args.push_back({ Compiler::StaticType::Bool, static_cast<LLVMRegister *>(cond) });
+    ins->args.push_back({ Compiler::StaticType::Bool, dynamic_cast<LLVMRegister *>(cond) });
     m_instructions.push_back(ins);
     pushLoopScope(false);
 }
@@ -2687,7 +2687,7 @@ LLVMRegister *LLVMCodeBuilder::createOp(const LLVMInstruction &ins, Compiler::St
     m_instructions.push_back(createdIns);
 
     for (size_t i = 0; i < args.size(); i++)
-        createdIns->args.push_back({ argTypes[i], static_cast<LLVMRegister *>(args[i]) });
+        createdIns->args.push_back({ argTypes[i], dynamic_cast<LLVMRegister *>(args[i]) });
 
     if (retType != Compiler::StaticType::Void) {
         auto ret = std::make_shared<LLVMRegister>(retType);
diff --git a/src/engine/internal/llvm/llvmconstantregister.h b/src/engine/internal/llvm/llvmconstantregister.h
@@ -10,16 +10,17 @@ namespace libscratchcpp
 {
 
 struct LLVMConstantRegister
-    : public LLVMRegisterBase
-    , public CompilerConstant
+    : public CompilerConstant
+    , public LLVMRegister
 {
         LLVMConstantRegister(Compiler::StaticType type, const Value &value) :
-            LLVMRegisterBase(),
-            CompilerConstant(type, value)
+            CompilerValue(type),
+            CompilerConstant(type, value),
+            LLVMRegister(type)
         {
         }
 
-        const Value &constValue() const override { return CompilerConstant::value(); }
+        const Value &constValue() const override final { return CompilerConstant::value(); }
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/internal/llvm/llvmregister.h b/src/engine/internal/llvm/llvmregister.h
@@ -2,7 +2,8 @@
 
 #pragma once
 
-#include "llvmregisterbase.h"
+#include <scratchcpp/compilervalue.h>
+#include <scratchcpp/value.h>
 
 namespace llvm
 {
@@ -14,25 +15,24 @@ class Value;
 namespace libscratchcpp
 {
 
-struct LLVMRegister
-    : public LLVMRegisterBase
-    , public CompilerValue
+class LLVMInstruction;
+
+struct LLVMRegister : public virtual CompilerValue
 {
         LLVMRegister(Compiler::StaticType type) :
-            LLVMRegisterBase(),
             CompilerValue(type)
         {
         }
 
-        const Value &constValue() const override
+        virtual const Value &constValue() const
         {
-            if (isConst())
-                return static_cast<const CompilerConstant *>(static_cast<const CompilerValue *>(this))->value();
-            else {
-                static const Value null = Value();
-                return null;
-            }
+            static const Value null = Value();
+            return null;
         }
+
+        llvm::Value *value = nullptr;
+        bool isRawValue = false;
+        std::shared_ptr<LLVMInstruction> instruction;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/internal/llvm/llvmregisterbase.h b/src/engine/internal/llvm/llvmregisterbase.h
diff --git a/test/llvm/llvmcodebuilder_test.cpp b/test/llvm/llvmcodebuilder_test.cpp
@@ -8,6 +8,7 @@
 #include <scratchcpp/variable.h>
 #include <scratchcpp/list.h>
 #include <scratchcpp/blockprototype.h>
+#include <scratchcpp/compilerconstant.h>
 #include <engine/internal/llvm/llvmcodebuilder.h>
 #include <engine/internal/llvm/llvmcompilercontext.h>
 #include <gmock/gmock.h>

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace libscratchcpp`
`10`	`10`	`class CompilerConstantPrivate;`
`11`	`11`
`12`	`12`	`/! \brief The CompilerConstant class represents a constant value in compiled code. /`
`13`		`-class LIBSCRATCHCPP_EXPORT CompilerConstant : public CompilerValue`
	`13`	`+class LIBSCRATCHCPP_EXPORT CompilerConstant : public virtual CompilerValue`
`14`	`14`	`{`
`15`	`15`	`public:`
`16`	`16`	`CompilerConstant(Compiler::StaticType type, const Value &value);`
Original file line number	Diff line number	Diff line change
`@@ -10,16 +10,17 @@ namespace libscratchcpp`
`10`	`10`	`{`
`11`	`11`
`12`	`12`	`struct LLVMConstantRegister`
`13`		`- : public LLVMRegisterBase`
`14`		`- , public CompilerConstant`
	`13`	`+ : public CompilerConstant`
	`14`	`+ , public LLVMRegister`
`15`	`15`	`{`
`16`	`16`	`LLVMConstantRegister(Compiler::StaticType type, const Value &value) :`
`17`		`- LLVMRegisterBase(),`
`18`		`- CompilerConstant(type, value)`
	`17`	`+ CompilerValue(type),`
	`18`	`+ CompilerConstant(type, value),`
	`19`	`+ LLVMRegister(type)`
`19`	`20`	`{`
`20`	`21`	`}`
`21`	`22`
`22`		`- const Value &constValue() const override { return CompilerConstant::value(); }`
	`23`	`+ const Value &constValue() const override final { return CompilerConstant::value(); }`
`23`	`24`	`};`
`24`	`25`
`25`	`26`	`} // namespace libscratchcpp`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,8 @@`
`2`	`2`
`3`	`3`	`#pragma once`
`4`	`4`
`5`		`-#include "llvmregisterbase.h"`
	`5`	`+#include <scratchcpp/compilervalue.h>`
	`6`	`+#include <scratchcpp/value.h>`
`6`	`7`
`7`	`8`	`namespace llvm`
`8`	`9`	`{`
`@@ -14,25 +15,24 @@ class Value;`
`14`	`15`	`namespace libscratchcpp`
`15`	`16`	`{`
`16`	`17`
`17`		`-struct LLVMRegister`
`18`		`- : public LLVMRegisterBase`
`19`		`- , public CompilerValue`
	`18`	`+class LLVMInstruction;`
	`19`	`+`
	`20`	`+struct LLVMRegister : public virtual CompilerValue`
`20`	`21`	`{`
`21`	`22`	`LLVMRegister(Compiler::StaticType type) :`
`22`		`- LLVMRegisterBase(),`
`23`	`23`	`CompilerValue(type)`
`24`	`24`	`{`
`25`	`25`	`}`
`26`	`26`
`27`		`- const Value &constValue() const override`
	`27`	`+ virtual const Value &constValue() const`
`28`	`28`	`{`
`29`		`- if (isConst())`
`30`		`- return static_cast<const CompilerConstant >(static_cast<const CompilerValue >(this))->value();`
`31`		`- else {`
`32`		`- static const Value null = Value();`
`33`		`- return null;`
`34`		`- }`
	`29`	`+ static const Value null = Value();`
	`30`	`+ return null;`
`35`	`31`	`}`
	`32`	`+`
	`33`	`+ llvm::Value *value = nullptr;`
	`34`	`+ bool isRawValue = false;`
	`35`	`+ std::shared_ptr<LLVMInstruction> instruction;`
`36`	`36`	`};`
`37`	`37`
`38`	`38`	`} // namespace libscratchcpp`