LLVMCodeBuilder: Add string concat instruction

adazem009 · adazem009 · commit 52c4d026f131 · 2025-02-14T15:38:04.000+01:00
diff --git a/src/engine/internal/icodebuilder.h b/src/engine/internal/icodebuilder.h
@@ -69,6 +69,8 @@ class ICodeBuilder
         virtual CompilerValue *createExp(CompilerValue *num) = 0;
         virtual CompilerValue *createExp10(CompilerValue *num) = 0;
 
+        virtual CompilerValue *createStringConcat(CompilerValue *string1, CompilerValue *string2) = 0;
+
         virtual CompilerValue *createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType) = 0;
 
         virtual CompilerLocalVariable *createLocalVariable(Compiler::StaticType type) = 0;
diff --git a/src/engine/internal/llvm/llvmcodebuilder.cpp b/src/engine/internal/llvm/llvmcodebuilder.cpp
@@ -547,6 +547,49 @@ std::shared_ptr<ExecutableCode> LLVMCodeBuilder::finalize()
                 break;
             }
 
+            case LLVMInstruction::Type::StringConcat: {
+                assert(step.args.size() == 2);
+                const auto &arg1 = step.args[0];
+                const auto &arg2 = step.args[1];
+                llvm::Value *str1 = castValue(arg1.second, arg1.first);
+                llvm::Value *str2 = castValue(arg2.second, arg2.first);
+                llvm::PointerType *charPointerType = m_builder.getInt16Ty()->getPointerTo();
+                llvm::Function *memcpyFunc = llvm::Intrinsic::getDeclaration(m_module, llvm::Intrinsic::memcpy_inline, { charPointerType, charPointerType, m_builder.getInt64Ty() });
+
+                // StringPtr *result = string_pool_new(true)
+                llvm::Value *result = m_builder.CreateCall(resolve_string_pool_new(), m_builder.getInt1(true));
+                freeStringLater(result);
+
+                // result->size = string1->size + string2->size
+                llvm::Value *sizeField1 = m_builder.CreateStructGEP(m_stringPtrType, str1, 1);
+                llvm::Value *sizeField2 = m_builder.CreateStructGEP(m_stringPtrType, str2, 1);
+                llvm::Value *size1 = m_builder.CreateLoad(m_builder.getInt64Ty(), sizeField1);
+                llvm::Value *size2 = m_builder.CreateLoad(m_builder.getInt64Ty(), sizeField2);
+                llvm::Value *resultSize = m_builder.CreateAdd(size1, size2);
+                llvm::Value *resultSizeField = m_builder.CreateStructGEP(m_stringPtrType, result, 1);
+                m_builder.CreateStore(resultSize, resultSizeField);
+
+                // string_alloc(result, result->size)
+                m_builder.CreateCall(resolve_string_alloc(), { result, resultSize });
+
+                // memcpy(result->data, string1->data, string1->size * sizeof(char16_t))
+                llvm::Value *dataField1 = m_builder.CreateStructGEP(m_stringPtrType, str1, 0);
+                llvm::Value *data1 = m_builder.CreateLoad(charPointerType, dataField1);
+                llvm::Value *resultDataField = m_builder.CreateStructGEP(m_stringPtrType, result, 0);
+                llvm::Value *writePtr = m_builder.CreateLoad(charPointerType, resultDataField);
+                m_builder.CreateCall(memcpyFunc, { writePtr, data1, m_builder.CreateMul(size1, m_builder.getInt64(2)), m_builder.getInt1(false) });
+
+                // memcpy(result->data + string1->size, string2->data, (string2->size + 1) * sizeof(char16_t))
+                // +1: null-terminate
+                llvm::Value *dataField2 = m_builder.CreateStructGEP(m_stringPtrType, str2, 0);
+                llvm::Value *data2 = m_builder.CreateLoad(charPointerType, dataField2);
+                writePtr = m_builder.CreateGEP(m_builder.getInt16Ty(), writePtr, size1);
+                m_builder.CreateCall(memcpyFunc, { writePtr, data2, m_builder.CreateMul(m_builder.CreateAdd(size2, m_builder.getInt64(1)), m_builder.getInt64(2)), m_builder.getInt1(false) });
+
+                step.functionReturnReg->value = result;
+                break;
+            }
+
             case LLVMInstruction::Type::Select: {
                 assert(step.args.size() == 3);
                 const auto &arg1 = step.args[0];
@@ -1556,6 +1599,11 @@ CompilerValue *LLVMCodeBuilder::createExp10(CompilerValue *num)
     return createOp(LLVMInstruction::Type::Exp10, Compiler::StaticType::Number, Compiler::StaticType::Number, { num });
 }
 
+CompilerValue *LLVMCodeBuilder::createStringConcat(CompilerValue *string1, CompilerValue *string2)
+{
+    return createOp(LLVMInstruction::Type::StringConcat, Compiler::StaticType::String, Compiler::StaticType::String, { string1, string2 });
+}
+
 CompilerValue *LLVMCodeBuilder::createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType)
 {
     LLVMRegister *ret = createOp(LLVMInstruction::Type::Select, valueType, { Compiler::StaticType::Bool, valueType, valueType }, { cond, trueValue, falseValue });
@@ -3217,6 +3265,11 @@ llvm::FunctionCallee LLVMCodeBuilder::resolve_string_pool_free()
     return resolveFunction("string_pool_free", llvm::FunctionType::get(m_builder.getVoidTy(), { m_stringPtrType->getPointerTo() }, false));
 }
 
+llvm::FunctionCallee LLVMCodeBuilder::resolve_string_alloc()
+{
+    return resolveFunction("string_alloc", llvm::FunctionType::get(m_builder.getVoidTy(), { m_stringPtrType->getPointerTo(), m_builder.getInt64Ty() }, false));
+}
+
 llvm::FunctionCallee LLVMCodeBuilder::resolve_string_compare_case_sensitive()
 {
     llvm::Type *stringPtr = m_stringPtrType->getPointerTo();
diff --git a/src/engine/internal/llvm/llvmcodebuilder.h b/src/engine/internal/llvm/llvmcodebuilder.h
@@ -78,6 +78,8 @@ class LLVMCodeBuilder : public ICodeBuilder
         CompilerValue *createExp(CompilerValue *num) override;
         CompilerValue *createExp10(CompilerValue *num) override;
 
+        CompilerValue *createStringConcat(CompilerValue *string1, CompilerValue *string2) override;
+
         CompilerValue *createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType) override;
 
         CompilerLocalVariable *createLocalVariable(Compiler::StaticType type) override;
@@ -204,6 +206,7 @@ class LLVMCodeBuilder : public ICodeBuilder
         llvm::FunctionCallee resolve_llvm_random_bool();
         llvm::FunctionCallee resolve_string_pool_new();
         llvm::FunctionCallee resolve_string_pool_free();
+        llvm::FunctionCallee resolve_string_alloc();
         llvm::FunctionCallee resolve_string_compare_case_sensitive();
         llvm::FunctionCallee resolve_string_compare_case_insensitive();
 
diff --git a/src/engine/internal/llvm/llvminstruction.h b/src/engine/internal/llvm/llvminstruction.h
@@ -47,6 +47,7 @@ struct LLVMInstruction
             Log10,
             Exp,
             Exp10,
+            StringConcat,
             Select,
             CreateLocalVariable,
             WriteLocalVariable,
diff --git a/test/llvm/llvmcodebuilder_test.cpp b/test/llvm/llvmcodebuilder_test.cpp
@@ -56,7 +56,8 @@ class LLVMCodeBuilderTest : public testing::Test
             Ln,
             Log10,
             Exp,
-            Exp10
+            Exp10,
+            StringConcat
         };
 
         void SetUp() override
@@ -144,6 +145,9 @@ class LLVMCodeBuilderTest : public testing::Test
                 case OpType::Mod:
                     return m_builder->createMod(arg1, arg2);
 
+                case OpType::StringConcat:
+                    return m_builder->createStringConcat(arg1, arg2);
+
                 default:
                     EXPECT_TRUE(false);
                     return nullptr;
@@ -258,6 +262,21 @@ class LLVMCodeBuilderTest : public testing::Test
                 case OpType::Mod:
                     return v1 % v2;
 
+                case OpType::StringConcat: {
+                    const StringPtr *string1 = value_toStringPtr(&v1.data());
+                    const StringPtr *string2 = value_toStringPtr(&v2.data());
+                    StringPtr *result = string_pool_new(true);
+
+                    result->size = string1->size + string2->size;
+                    string_alloc(result, result->size);
+                    memcpy(result->data, string1->data, string1->size * sizeof(typeof(*string1->data)));
+                    memcpy(result->data + string1->size, string2->data, (string2->size + 1) * sizeof(typeof(*string2->data))); // +1: null-terminate
+
+                    ValueData data;
+                    value_assign_stringPtr(&data, result);
+                    return Value(data);
+                }
+
                 default:
                     EXPECT_TRUE(false);
                     return Value();
@@ -1700,6 +1719,13 @@ TEST_F(LLVMCodeBuilderTest, Exp10)
     runUnaryNumOpTest(OpType::Exp10, nan, 1.0);
 }
 
+TEST_F(LLVMCodeBuilderTest, StringConcat)
+{
+    runOpTest(OpType::StringConcat, "Hello ", "world");
+    runOpTest(OpType::StringConcat, "abc", "def");
+    runOpTest(OpType::StringConcat, "ábč", "ďéfgh");
+}
+
 TEST_F(LLVMCodeBuilderTest, LocalVariables)
 {
     Stage stage;
diff --git a/test/mocks/codebuildermock.h b/test/mocks/codebuildermock.h
@@ -58,6 +58,8 @@ class CodeBuilderMock : public ICodeBuilder
         MOCK_METHOD(CompilerValue *, createExp, (CompilerValue *), (override));
         MOCK_METHOD(CompilerValue *, createExp10, (CompilerValue *), (override));
 
+        MOCK_METHOD(CompilerValue *, createStringConcat, (CompilerValue *, CompilerValue *), (override));
+
         MOCK_METHOD(CompilerValue *, createSelect, (CompilerValue *, CompilerValue *, CompilerValue *, Compiler::StaticType), (override));
 
         MOCK_METHOD(CompilerLocalVariable *, createLocalVariable, (Compiler::StaticType), (override));
