Refactor string allocation

Strings should be allocated only in the beginning of scripts. They are deallocated when the thread is destroyed.

Author: adazem009

src/engine/internal/llvm/instructions/functions.cpp

@@ -36,7 +36,7 @@ LLVMInstruction *Functions::buildFunctionCall(LLVMInstruction *ins)
     llvm::Value *stringRet = nullptr;
 
     if (ins->functionReturnReg && ins->functionReturnReg->type() == Compiler::StaticType::String) {
-        stringRet = m_builder.CreateCall(m_utils.functions().resolve_string_pool_new(), { m_builder.getInt1(true) });
+        stringRet = m_utils.addStringAlloca();
         types.push_back(m_utils.getType(Compiler::StaticType::String, false));
         args.push_back(stringRet);
     }
@@ -63,10 +63,9 @@ LLVMInstruction *Functions::buildFunctionCall(LLVMInstruction *ins)
     llvm::Value *ret = m_builder.CreateCall(m_utils.functions().resolveFunction(ins->functionName, llvm::FunctionType::get(retType, types, false)), args);
 
     if (ins->functionReturnReg) {
-        if (ins->functionReturnReg->type() == Compiler::StaticType::String) {
+        if (ins->functionReturnReg->type() == Compiler::StaticType::String)
             ins->functionReturnReg->value = stringRet;
-            m_utils.freeStringLater(stringRet);
-        } else if (m_utils.isSingleType(ins->functionReturnReg->type()))
+        else if (m_utils.isSingleType(ins->functionReturnReg->type()))
             ins->functionReturnReg->value = ret;
         else {
             ins->functionReturnReg->value = m_utils.addAlloca(retType);

src/engine/internal/llvm/instructions/lists.cpp

@@ -270,9 +270,8 @@ LLVMInstruction *Lists::buildGetListContents(LLVMInstruction *ins)
 {
     assert(ins->args.size() == 0);
     const LLVMListPtr &listPtr = m_utils.listPtr(ins->targetList);
-    llvm::Value *ptr = m_builder.CreateCall(m_utils.functions().resolve_string_pool_new(), { m_builder.getInt1(true) });
+    llvm::Value *ptr = m_utils.addStringAlloca();
     m_builder.CreateCall(m_utils.functions().resolve_list_to_string(), { listPtr.ptr, ptr });
-    m_utils.freeStringLater(ptr);
     ins->functionReturnReg->value = ptr;
 
     return ins->next;

src/engine/internal/llvm/instructions/string.cpp

@@ -44,9 +44,8 @@ LLVMInstruction *String::buildStringConcat(LLVMInstruction *ins)
     llvm::StructType *stringPtrType = m_utils.compilerCtx()->stringPtrType();
     llvm::Function *memcpyFunc = llvm::Intrinsic::getDeclaration(m_utils.module(), llvm::Intrinsic::memcpy_inline, { charPointerType, charPointerType, m_builder.getInt64Ty() });
 
-    // StringPtr *result = string_pool_new(true)
-    llvm::Value *result = m_builder.CreateCall(m_utils.functions().resolve_string_pool_new(), m_builder.getInt1(true));
-    m_utils.freeStringLater(result);
+    // StringPtr *result = (allocated string)
+    llvm::Value *result = m_utils.addStringAlloca();
 
     // result->size = string1->size + string2->size
     llvm::Value *sizeField1 = m_builder.CreateStructGEP(stringPtrType, str1, 1);
@@ -100,8 +99,7 @@ LLVMInstruction *String::buildStringChar(LLVMInstruction *ins)
     llvm::Value *charPtr = m_builder.CreateGEP(m_builder.getInt16Ty(), data, index);
 
     // Allocate string
-    llvm::Value *result = m_builder.CreateCall(m_utils.functions().resolve_string_pool_new(), m_builder.getInt1(true));
-    m_utils.freeStringLater(result);
+    llvm::Value *result = m_utils.addStringAlloca();
     m_builder.CreateCall(m_utils.functions().resolve_string_alloc(), { result, m_builder.getInt64(1) }); // size 1 to avoid branching
 
     // Get result data ptr

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -395,16 +395,6 @@ void LLVMBuildUtils::popScopeLevel()
     m_stringHeap.pop_back();
 }
 
-void LLVMBuildUtils::freeStringLater(llvm::Value *value)
-{
-    assert(!m_stringHeap.empty());
-
-    if (m_stringHeap.empty())
-        return;
-
-    m_stringHeap.back().push_back(value);
-}
-
 void LLVMBuildUtils::freeScopeHeap()
 {
     if (m_stringHeap.empty())
@@ -468,6 +458,16 @@ llvm::Value *LLVMBuildUtils::addAlloca(llvm::Type *type)
     return ret;
 }
 
+llvm::Value *LLVMBuildUtils::addStringAlloca()
+{
+    // NOTE: The string will be deallocated when the thread is destroyed
+    llvm::BasicBlock *block = m_builder.GetInsertBlock();
+    m_builder.SetInsertPointPastAllocas(m_function);
+    llvm::Value *ret = m_builder.CreateCall(m_functions.resolve_string_pool_new(), { m_builder.getInt1(true) }, "localString");
+    m_builder.SetInsertPoint(block);
+    return ret;
+}
+
 llvm::Value *LLVMBuildUtils::castValue(LLVMRegister *reg, Compiler::StaticType targetType, NumberType targetNumType)
 {
     if (reg->isConst()) {
@@ -629,7 +629,7 @@ llvm::Value *LLVMBuildUtils::castValue(LLVMRegister *reg, Compiler::StaticType t
                 llvm::Value *intCast = m_builder.CreateSIToFP(reg->intValue, m_builder.getDoubleTy());
                 llvm::Value *value = m_builder.CreateSelect(reg->isInt, intCast, doubleValue);
 
-                llvm::Value *numberResult = m_builder.CreateCall(m_functions.resolve_string_pool_new(), { m_builder.getInt1(true) });
+                llvm::Value *numberResult = addStringAlloca();
                 m_builder.CreateCall(m_functions.resolve_value_doubleToStringPtr(), { value, numberResult });
                 m_builder.CreateBr(mergeBlock);
                 results.push_back({ numberBlock, numberResult });
@@ -640,13 +640,10 @@ llvm::Value *LLVMBuildUtils::castValue(LLVMRegister *reg, Compiler::StaticType t
                 llvm::BasicBlock *boolBlock = llvm::BasicBlock::Create(m_llvmCtx, "bool", m_function);
                 sw->addCase(m_builder.getInt32(static_cast<uint32_t>(ValueType::Bool)), boolBlock);
 
-                // Since the value is deallocated later, we need to create a copy
                 m_builder.SetInsertPoint(boolBlock);
                 llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, reg->value, 0);
                 llvm::Value *value = m_builder.CreateLoad(m_builder.getInt1Ty(), ptr);
-                llvm::Value *stringPtr = m_builder.CreateCall(m_functions.resolve_value_boolToStringPtr(), value);
-                llvm::Value *boolResult = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(true));
-                m_builder.CreateCall(m_functions.resolve_string_assign(), { boolResult, stringPtr });
+                llvm::Value *boolResult = m_builder.CreateCall(m_functions.resolve_value_boolToStringPtr(), value);
                 m_builder.CreateBr(mergeBlock);
                 results.push_back({ boolBlock, boolResult });
             }
@@ -658,9 +655,7 @@ llvm::Value *LLVMBuildUtils::castValue(LLVMRegister *reg, Compiler::StaticType t
 
                 m_builder.SetInsertPoint(stringBlock);
                 llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, reg->value, 0);
-                llvm::Value *stringPtr = m_builder.CreateLoad(m_stringPtrType->getPointerTo(), ptr);
-                llvm::Value *stringResult = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(true));
-                m_builder.CreateCall(m_functions.resolve_string_assign(), { stringResult, stringPtr });
+                llvm::Value *stringResult = m_builder.CreateLoad(m_stringPtrType->getPointerTo(), ptr);
                 m_builder.CreateBr(mergeBlock);
                 results.push_back({ stringBlock, stringResult });
             }
@@ -1504,9 +1499,8 @@ llvm::Value *LLVMBuildUtils::castRawValue(LLVMRegister *reg, Compiler::StaticTyp
                     // Convert double/int to string
                     llvm::Value *intCast = m_builder.CreateSIToFP(reg->intValue, m_builder.getDoubleTy());
                     llvm::Value *doubleValue = m_builder.CreateSelect(reg->isInt, intCast, reg->value);
-                    llvm::Value *ptr = m_builder.CreateCall(m_functions.resolve_string_pool_new(), { m_builder.getInt1(true) });
+                    llvm::Value *ptr = addStringAlloca();
                     m_builder.CreateCall(m_functions.resolve_value_doubleToStringPtr(), { doubleValue, ptr });
-                    freeStringLater(ptr);
                     return ptr;
                 }
 
@@ -1800,10 +1794,9 @@ llvm::Value *LLVMBuildUtils::createNumberAndStringComparison(LLVMRegister *arg1,
 
     // String comparison
     m_builder.SetInsertPoint(stringBlock);
-    llvm::Value *stringValue = m_builder.CreateCall(m_functions.resolve_string_pool_new(), { m_builder.getInt1(true) });
+    llvm::Value *stringValue = addStringAlloca();
     m_builder.CreateCall(m_functions.resolve_value_doubleToStringPtr(), { value1, stringValue });
     llvm::Value *cmp = m_builder.CreateCall(m_functions.resolve_string_compare_case_insensitive(), { stringValue, value2 });
-    m_builder.CreateCall(m_functions.resolve_string_pool_free(), { stringValue }); // free the string immediately
 
     llvm::Value *zero = llvm::ConstantInt::get(m_builder.getInt32Ty(), 0, true);
     llvm::Value *stringCmp;

src/engine/internal/llvm/llvmbuildutils.h

@@ -77,7 +77,6 @@ class LLVMBuildUtils
         void pushScopeLevel();
         void popScopeLevel();
 
-        void freeStringLater(llvm::Value *value);
         void freeScopeHeap();
 
         std::vector<LLVMIfStatement> &ifStatements();
@@ -89,6 +88,8 @@ class LLVMBuildUtils
         static bool isSingleType(Compiler::StaticType type);
 
         llvm::Value *addAlloca(llvm::Type *type);
+        llvm::Value *addStringAlloca();
+
         llvm::Value *castValue(LLVMRegister *reg, Compiler::StaticType targetType, NumberType targetNumType = NumberType::Double);
         llvm::Type *getType(Compiler::StaticType type, bool isReturnType);
         llvm::Value *isNaN(llvm::Value *num);