LLVMCodeBuilder: Add string length instruction

Author: adazem009

src/engine/internal/icodebuilder.h

@@ -25,6 +25,7 @@ class ICodeBuilder
         virtual CompilerValue *addFunctionCallWithCtx(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) = 0;
         virtual CompilerConstant *addConstValue(const Value &value) = 0;
         virtual CompilerValue *addStringChar(CompilerValue *string, CompilerValue *index) = 0;
+        virtual CompilerValue *addStringLength(CompilerValue *string) = 0;
         virtual CompilerValue *addLoopIndex() = 0;
         virtual CompilerValue *addLocalVariableValue(CompilerLocalVariable *variable) = 0;
         virtual CompilerValue *addVariableValue(Variable *variable) = 0;

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -629,6 +629,16 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::StringLength: {
+                assert(step.args.size() == 1);
+                const auto &arg = step.args[0];
+                llvm::Value *str = castValue(arg.second, arg.first);
+                llvm::Value *sizeField = m_builder.CreateStructGEP(m_stringPtrType, str, 1);
+                llvm::Value *size = m_builder.CreateLoad(m_builder.getInt64Ty(), sizeField);
+                step.functionReturnReg->value = m_builder.CreateSIToFP(size, m_builder.getDoubleTy());
+                break;
+            }
+
             case LLVMInstruction::Type::Select: {
                 assert(step.args.size() == 3);
                 const auto &arg1 = step.args[0];
@@ -1379,6 +1389,11 @@ CompilerValue *LLVMCodeBuilder::addStringChar(CompilerValue *string, CompilerVal
     return createOp(LLVMInstruction::Type::StringChar, Compiler::StaticType::String, { Compiler::StaticType::String, Compiler::StaticType::Number }, { string, index });
 }
 
+CompilerValue *LLVMCodeBuilder::addStringLength(CompilerValue *string)
+{
+    return createOp(LLVMInstruction::Type::StringLength, Compiler::StaticType::Number, Compiler::StaticType::String, { string });
+}
+
 CompilerValue *LLVMCodeBuilder::addLoopIndex()
 {
     return createOp(LLVMInstruction::Type::LoopIndex, Compiler::StaticType::Number, {}, {});

src/engine/internal/llvm/llvmcodebuilder.h

@@ -34,6 +34,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         CompilerValue *addFunctionCallWithCtx(const std::string &functionName, Compiler::StaticType returnType, const Compiler::ArgTypes &argTypes, const Compiler::Args &args) override;
         CompilerConstant *addConstValue(const Value &value) override;
         CompilerValue *addStringChar(CompilerValue *string, CompilerValue *index) override;
+        CompilerValue *addStringLength(CompilerValue *string) override;
         CompilerValue *addLoopIndex() override;
         CompilerValue *addLocalVariableValue(CompilerLocalVariable *variable) override;
         CompilerValue *addVariableValue(Variable *variable) override;

src/engine/internal/llvm/llvminstruction.h

@@ -49,6 +49,7 @@ struct LLVMInstruction
             Exp10,
             StringConcat,
             StringChar,
+            StringLength,
             Select,
             CreateLocalVariable,
             WriteLocalVariable,

test/llvm/llvmcodebuilder_test.cpp

@@ -58,7 +58,8 @@ class LLVMCodeBuilderTest : public testing::Test
             Exp,
             Exp10,
             StringConcat,
-            StringChar
+            StringChar,
+            StringLength
         };
 
         void SetUp() override
@@ -209,6 +210,9 @@ class LLVMCodeBuilderTest : public testing::Test
                 case OpType::Exp10:
                     return m_builder->createExp10(arg);
 
+                case OpType::StringLength:
+                    return m_builder->addStringLength(arg);
+
                 default:
                     EXPECT_TRUE(false);
                     return nullptr;
@@ -309,6 +313,9 @@ class LLVMCodeBuilderTest : public testing::Test
                 case OpType::Not:
                     return !v.toBool();
 
+                case OpType::StringLength:
+                    return v.toUtf16().size();
+
                 default:
                     EXPECT_TRUE(false);
                     return Value();
@@ -1757,6 +1764,14 @@ TEST_F(LLVMCodeBuilderTest, StringChar)
     runOpTest(OpType::StringChar, "ábč", 0);
 }
 
+TEST_F(LLVMCodeBuilderTest, StringLength)
+{
+    runUnaryNumOpTest(OpType::StringLength, "Hello world", 11);
+    runUnaryNumOpTest(OpType::StringLength, "abc", 3);
+    runUnaryNumOpTest(OpType::StringLength, "abcdef", 6);
+    runUnaryNumOpTest(OpType::StringLength, "ábč", 3);
+}
+
 TEST_F(LLVMCodeBuilderTest, LocalVariables)
 {
     Stage stage;

test/mocks/codebuildermock.h

@@ -14,6 +14,7 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(CompilerValue *, addFunctionCallWithCtx, (const std::string &, Compiler::StaticType, const Compiler::ArgTypes &, const Compiler::Args &), (override));
         MOCK_METHOD(CompilerConstant *, addConstValue, (const Value &), (override));
         MOCK_METHOD(CompilerValue *, addStringChar, (CompilerValue *, CompilerValue *), (override));
+        MOCK_METHOD(CompilerValue *, addStringLength, (CompilerValue *), (override));
         MOCK_METHOD(CompilerValue *, addLoopIndex, (), (override));
         MOCK_METHOD(CompilerValue *, addLocalVariableValue, (CompilerLocalVariable *), (override));
         MOCK_METHOD(CompilerValue *, addVariableValue, (Variable *), (override));