Add support for mixed types in function return values

Author: adazem009

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

@@ -54,11 +54,12 @@ 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::Unknown) {
+        if (m_utils.isSingleType(ins->functionReturnReg->type()))
+            ins->functionReturnReg->value = ret;
+        else {
             ins->functionReturnReg->value = m_utils.addAlloca(retType);
             m_builder.CreateStore(ret, ins->functionReturnReg->value);
-        } else
-            ins->functionReturnReg->value = ret;
+        }
 
         if (ins->functionReturnReg->type() == Compiler::StaticType::String)
             m_utils.freeStringLater(ins->functionReturnReg->value);

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -383,6 +383,12 @@ Compiler::StaticType LLVMBuildUtils::mapType(ValueType type)
     return TYPE_MAP[type];
 }
 
+bool LLVMBuildUtils::isSingleType(Compiler::StaticType type)
+{
+    // Check if the type is a power of 2 (only one bit set)
+    return (type & (static_cast<Compiler::StaticType>(static_cast<int>(type) - 1))) == static_cast<Compiler::StaticType>(0);
+}
+
 llvm::Value *LLVMBuildUtils::addAlloca(llvm::Type *type)
 {
     // Add an alloca to the entry block because allocas must be there (to avoid stack overflow)
@@ -509,15 +515,12 @@ llvm::Type *LLVMBuildUtils::getType(Compiler::StaticType type, bool isReturnType
         case Compiler::StaticType::Pointer:
             return m_builder.getVoidTy()->getPointerTo();
 
-        case Compiler::StaticType::Unknown:
+        default:
+            // Multiple types
             if (isReturnType)
                 return m_valueDataType;
             else
                 return m_valueDataType->getPointerTo();
-
-        default:
-            assert(false);
-            return nullptr;
     }
 }
 

src/engine/internal/llvm/llvmbuildutils.h

@@ -75,6 +75,7 @@ class LLVMBuildUtils
 
         static Compiler::StaticType optimizeRegisterType(const LLVMRegister *reg);
         static Compiler::StaticType mapType(ValueType type);
+        static bool isSingleType(Compiler::StaticType type);
 
         llvm::Value *addAlloca(llvm::Type *type);
         llvm::Value *castValue(LLVMRegister *reg, Compiler::StaticType targetType);

src/engine/internal/llvm/llvmcodebuilder.cpp

@@ -101,7 +101,7 @@ CompilerValue *LLVMCodeBuilder::addFunctionCall(const std::string &functionName,
     if (returnType != Compiler::StaticType::Void) {
         auto reg = std::make_shared<LLVMRegister>(returnType);
 
-        if (returnType != Compiler::StaticType::Unknown)
+        if (m_utils.isSingleType(returnType))
             reg->isRawValue = true;
 
         ins->functionReturnReg = reg.get();