diff --git a/.github/workflows/ci-cpp.yml b/.github/workflows/ci-cpp.yml index b13c16cb5..f01e2d4f0 100644 --- a/.github/workflows/ci-cpp.yml +++ b/.github/workflows/ci-cpp.yml @@ -12,7 +12,7 @@ on: jobs: build: name: C++ CI - runs-on: ubuntu-latest + runs-on: ubuntu-22.04 steps: - name: Checkout @@ -24,10 +24,10 @@ jobs: distribution: zulu java-version: 11 - - name: Setup latest GCC and build dependencies + - name: Setup latest Clang and build dependencies run: | - sudo apt install gcc-11 g++-11 - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11 --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-11 --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-11 + sudo apt install gcc-12 g++-12 + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 110 --slave /usr/bin/g++ g++ /usr/bin/g++-12 --slave /usr/bin/gcov gcov /usr/bin/gcov-12 --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-12 --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-12 - name: Setup Ninja run: sudo apt-get install ninja-build @@ -43,14 +43,14 @@ jobs: uses: actions/cache@v3 with: path: /home/runner/work/spice/llvm - key: llvm-15.0.0-rc3 + key: llvm-15.0.0 - name: Setup LLVM if: steps.cache-llvm.outputs.cache-hit != 'true' run: | cd .. rm -rf llvm - git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project llvm + git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project llvm mkdir ./llvm/build cd ./llvm/build cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS_RELEASE="-O2" -GNinja ../llvm diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 3caaffe1a..f59bd1970 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -9,7 +9,7 @@ on: jobs: analyze-cpp: name: Analyze C++ Code - runs-on: ubuntu-latest + runs-on: ubuntu-22.04 steps: - name: Checkout uses: actions/checkout@v3 @@ -41,13 +41,13 @@ jobs: uses: actions/cache@v3 with: path: /home/runner/work/spice/llvm - key: 15.0.0-rc3 + key: 15.0.0 - name: Setup LLVM if: steps.cache-llvm.outputs.cache-hit != 'true' run: | cd .. - git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project llvm + git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project llvm mkdir ./llvm/build cd ./llvm/build cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS_RELEASE="-O2" -GNinja ../llvm diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 3e4e601fa..bb8da3f95 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -14,7 +14,7 @@ on: jobs: docs-deploy: - runs-on: ubuntu-latest + runs-on: ubuntu-22.04 steps: - name: Checkout uses: actions/checkout@v3 @@ -29,4 +29,4 @@ jobs: - name: Build and deploy working-directory: docs - run: mkdocs gh-deploy --force + run: mkdocs gh-deploy --force \ No newline at end of file diff --git a/.github/workflows/misspell.yml b/.github/workflows/misspell.yml index 1f7632f61..fbdad646c 100644 --- a/.github/workflows/misspell.yml +++ b/.github/workflows/misspell.yml @@ -10,11 +10,11 @@ on: jobs: spellcheck: - runs-on: ubuntu-latest + runs-on: ubuntu-22.04 steps: - name: Checkout uses: actions/checkout@v3 - + - name: Misspell uses: reviewdog/action-misspell@v1 with: diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 7b29cc990..d8eb0e558 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -9,7 +9,7 @@ on: jobs: build-compiler-linux: name: Build compiler binaries - Linux - runs-on: ubuntu-latest + runs-on: ubuntu-22.04 steps: - name: Checkout @@ -30,8 +30,8 @@ jobs: - name: Setup latest GCC and build dependencies run: | - sudo apt install gcc-11 g++-11 - sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11 --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-11 --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-11 + sudo apt install gcc-12 g++-12 + sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 110 --slave /usr/bin/g++ g++ /usr/bin/g++-12 --slave /usr/bin/gcov gcov /usr/bin/gcov-12 --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-12 --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-12 - name: Setup Ninja uses: seanmiddleditch/gha-setup-ninja@master @@ -44,12 +44,12 @@ jobs: uses: actions/cache@v3 with: path: /home/runner/work/spice/spice/llvm - key: llvm-15.0.0-rc3-linux-x64 + key: llvm-15.0.0-linux-x64 - name: Setup LLVM if: steps.cache-llvm.outputs.cache-hit != 'true' run: | - git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project.git llvm + git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project.git llvm mkdir ./llvm/build cd ./llvm/build cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++ -DCMAKE_CXX_FLAGS_RELEASE="-O2" -GNinja -Wno-dev -Wattributes ../llvm @@ -109,9 +109,9 @@ jobs: choco uninstall llvm --all-versions Remove-Item -Recurse -Force C:/Strawberry echo "Uninstalling done." - Invoke-WebRequest https://chillibits.com/files/gh/mingw64_12_1_0.zip -OutFile mingw64.zip + Invoke-WebRequest https://chillibits.com/files/gh/mingw64_12_2_0.7z -OutFile mingw64.7z echo "Downloading done." - 7z x mingw64.zip -oC:\mingw64 + 7z x mingw64.7z -oC:\mingw64 echo "Unpacking done." Copy-Item -Path C:\mingw64\mingw64\bin\mingw32-make.exe -Destination C:\mingw64\mingw64\bin\make.exe echo "All done." @@ -124,12 +124,12 @@ jobs: uses: actions/cache@v3 with: path: D:/a/spice/spice/llvm - key: llvm-15.0.0-rc3-win-x64 + key: llvm-15.0.0-win-x64 - name: Setup LLVM if: steps.cache-llvm.outputs.cache-hit != 'true' run: | - git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project.git llvm + git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project.git llvm setx /M PATH "%PATH%;C:\mingw64\mingw64\bin" $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User") echo "Adding MinGW to path done." @@ -259,6 +259,7 @@ jobs: - name: Deploy to Debian / Raspbian repo run: | + curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/debian-bookworm/" curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/debian-bullseye/" curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/debian-buster/" curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/debian-stretch/" @@ -273,6 +274,7 @@ jobs: curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/ubuntu-bionic/" curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/ubuntu-xenial/" curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/ubuntu-trusty/" + curl -sSf -u "${{ secrets.NEXUS_USERNAME }}:${{ secrets.NEXUS_PASSWORD }}" -H "Content-Type: multipart/form-data" --data-binary "@./spice_${{ matrix.arch }}.deb" "${{ secrets.NEXUS_URL }}/ubuntu-jammy/" - name: Deploy to CentOS repo run: | diff --git a/.run/Spice_run.run.xml b/.run/Spice_run.run.xml index 97eb8b784..67ebee1e4 100644 --- a/.run/Spice_run.run.xml +++ b/.run/Spice_run.run.xml @@ -1,5 +1,5 @@ - + diff --git a/CMakeLists.txt b/CMakeLists.txt index a6225966c..260c9e08b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,7 +15,7 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s -O2") LIST(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src/cmake) add_definitions(-DANTLR4CPP_STATIC) include(ExternalAntlr4Cpp) -set(ANTLR_EXECUTABLE ${CMAKE_CURRENT_SOURCE_DIR}/src/thirdparty/antlr-4.10.1-complete.jar) +set(ANTLR_EXECUTABLE ${CMAKE_CURRENT_SOURCE_DIR}/src/thirdparty/antlr-4.11.1-complete.jar) # Find Google Test add_subdirectory(lib/googletest) diff --git a/dev-setup.bat b/dev-setup.bat index 5d45459a0..a4587b59e 100644 --- a/dev-setup.bat +++ b/dev-setup.bat @@ -27,7 +27,7 @@ echo done. REM - Clone LLVM echo [Step 2] Cloning LLVM (Could take a while) ... -git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project llvm +git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project llvm echo done. REM - Build LLVM diff --git a/dev-setup.sh b/dev-setup.sh index bddda4a97..2c06e0844 100644 --- a/dev-setup.sh +++ b/dev-setup.sh @@ -10,13 +10,12 @@ colored_echo() { colored_echo "[Step 1] Installing dependencies via Linux packages (Could take a while) ... " sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test sudo apt update -y -sudo apt-get install -y cmake make ninja-build uuid-dev openjdk-11-jre-headless gcc-11 g++-11 -sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 110 --slave /usr/bin/g++ g++ /usr/bin/g++-11 --slave /usr/bin/gcov gcov /usr/bin/gcov-11 --slave /usr/bin/gcc-ar gcc-ar /usr/bin/gcc-ar-11 --slave /usr/bin/gcc-ranlib gcc-ranlib /usr/bin/gcc-ranlib-11 +sudo apt-get install -y cmake make ninja-build uuid-dev openjdk-11-jre-headless colored_echo "done." # Clone LLVM colored_echo "[Step 2] Cloning LLVM (Could take a while) ... " -git clone --depth 1 --branch llvmorg-15.0.0-rc3 https://github.com/llvm/llvm-project llvm +git clone --depth 1 --branch llvmorg-15.0.0 https://github.com/llvm/llvm-project llvm colored_echo "done." # Build LLVM diff --git a/docs/docs/language/enums.md b/docs/docs/language/enums.md index a2bc37b54..6e7070e03 100644 --- a/docs/docs/language/enums.md +++ b/docs/docs/language/enums.md @@ -2,7 +2,7 @@ title: Enumerations --- -Enumerations in spice work like this: +Enumerations in Spice work like this: ```spice type Fruit enum { diff --git a/media/setup-guide-windows.md b/media/setup-guide-windows.md index e1def7fd8..d0cba63b5 100644 --- a/media/setup-guide-windows.md +++ b/media/setup-guide-windows.md @@ -1,5 +1,5 @@ # Setup Guide for Windows -- Download and install MinGW64 from [here](https://winlibs.com/) +- Download and install MinGW64 with LLVM from [here](https://winlibs.com/) - Build LLVM with the included GCC version - Delete CMake output directories in Spice project and re-build Spice \ No newline at end of file diff --git a/media/test-project/os-test.spice b/media/test-project/os-test.spice index a5c00ab1e..1cccb43ad 100644 --- a/media/test-project/os-test.spice +++ b/media/test-project/os-test.spice @@ -1,3 +1,7 @@ +f main() { + printf("Test: %s", "Hi " + "World!"); +} + /*import "std/data/vector" as vec; import "std/data/pair" as pair; @@ -17,10 +21,34 @@ f main() { server.serve("/test", "Hello World!"); }*/ -import "std/runtime/string_rt" as _rt_str; +/*import "std/runtime/string_rt" as _rt_str; + +f main() { + //_rt_str::String s = _rt_str::String("Test"); + //printf("%s", s.getRaw()); + // Plus + printf("Result: %s\n", "Hello " + "World!"); + string s1 = "Hello " + "World!"; + printf("Result: %s\n", s1); + // Mul + printf("Result: %s\n", 4s * "Hi"); + string s2 = "Hello " * 5; + printf("Result: %s\n", s2); + printf("Result: %s\n", 20 * 'a'); + string s3 = 2 * 'c' * 7; + printf("Result: %s\n", s3); + //printf("%s", s1 + s2); +}*/ + +/*public f src(int x, int y) { + return x + (x | -x); +} + +public f tgt(int x) { + return x & (x - 1); +} f main() { - string s = "Test"; - s *= 3; - printf("%s", s); -} \ No newline at end of file + printf("Src: %d\n", src(21, 10)); + printf("Tgt: %d\n", tgt(21)); +}*/ \ No newline at end of file diff --git a/setup-libs.bat b/setup-libs.bat index 0fa2aa83d..b114428d6 100644 --- a/setup-libs.bat +++ b/setup-libs.bat @@ -3,7 +3,7 @@ mkdir lib pushd lib -git clone --depth 1 --branch 4.10.1 https://github.com/antlr/antlr4.git +git clone --depth 1 --branch 4.11.1 https://github.com/antlr/antlr4.git git clone --depth 1 --branch release-1.12.1 https://github.com/google/googletest.git diff --git a/setup-libs.sh b/setup-libs.sh index f4aabba30..0d25132e0 100755 --- a/setup-libs.sh +++ b/setup-libs.sh @@ -3,7 +3,7 @@ mkdir lib cd lib || exit -git clone --depth 1 --branch 4.10.1 https://github.com/antlr/antlr4.git +git clone --depth 1 --branch 4.11.1 https://github.com/antlr/antlr4.git git clone --depth 1 --branch release-1.12.1 https://github.com/google/googletest.git diff --git a/src/analyzer/AnalyzerVisitor.cpp b/src/analyzer/AnalyzerVisitor.cpp index 7d57a8800..3319edc4f 100644 --- a/src/analyzer/AnalyzerVisitor.cpp +++ b/src/analyzer/AnalyzerVisitor.cpp @@ -32,7 +32,7 @@ AnalyzerVisitor::AnalyzerVisitor(std::shared_ptr context, std } // Create OpRuleManager - opRuleManager = std::make_unique(allowUnsafeOperations); + opRuleManager = std::make_unique(this); } std::any AnalyzerVisitor::visitEntry(EntryNode *node) { @@ -192,7 +192,7 @@ std::any AnalyzerVisitor::visitFctDef(FctDefNode *node) { throw SemanticError(node->codeLoc, UNEXPECTED_DYN_TYPE_SA, "Dyn return types are not allowed"); if (returnType.isPointer()) throw SemanticError(node->codeLoc, COMING_SOON_SA, - "Spice currently not supports pointer return types due to not supporting heap allocations."); + "Spice currently not supports pointer return types due to not handling pointer escaping."); currentScope->insert(RETURN_VARIABLE_NAME, returnType, SymbolSpecifiers(returnType), DECLARED, node); // Return to old scope @@ -273,7 +273,7 @@ std::any AnalyzerVisitor::visitFctDef(FctDefNode *node) { SymbolType returnType = spiceFunc.getReturnType(); if (returnType.isPointer()) throw SemanticError(node->codeLoc, COMING_SOON_SA, - "Spice currently not supports pointer return types due to not supporting heap allocations."); + "Spice currently not supports pointer return types due to not handling pointer escaping."); returnVarEntry->updateType(returnType, true); } @@ -1296,11 +1296,11 @@ std::any AnalyzerVisitor::visitAssignExpr(AssignExprNode *node) { if (node->op == AssignExprNode::OP_ASSIGN) { rhsTy = opRuleManager->getAssignResultType(node->codeLoc, lhsTy, rhsTy); } else if (node->op == AssignExprNode::OP_PLUS_EQUAL) { - rhsTy = opRuleManager->getPlusEqualResultType(node->codeLoc, lhsTy, rhsTy); + rhsTy = opRuleManager->getPlusEqualResultType(node, lhsTy, rhsTy); } else if (node->op == AssignExprNode::OP_MINUS_EQUAL) { rhsTy = opRuleManager->getMinusEqualResultType(node->codeLoc, lhsTy, rhsTy); } else if (node->op == AssignExprNode::OP_MUL_EQUAL) { - rhsTy = opRuleManager->getMulEqualResultType(node->codeLoc, lhsTy, rhsTy); + rhsTy = opRuleManager->getMulEqualResultType(node, lhsTy, rhsTy); } else if (node->op == AssignExprNode::OP_DIV_EQUAL) { rhsTy = opRuleManager->getDivEqualResultType(node->codeLoc, lhsTy, rhsTy); } else if (node->op == AssignExprNode::OP_REM_EQUAL) { @@ -1507,7 +1507,7 @@ std::any AnalyzerVisitor::visitAdditiveExpr(AdditiveExprNode *node) { switch (opQueue.front().first) { case AdditiveExprNode::OP_PLUS: - currentType = opRuleManager->getPlusResultType(operand->codeLoc, currentType, operandType); + currentType = opRuleManager->getPlusResultType(operand, currentType, operandType); break; case AdditiveExprNode::OP_MINUS: currentType = opRuleManager->getMinusResultType(operand->codeLoc, currentType, operandType); @@ -1541,7 +1541,7 @@ std::any AnalyzerVisitor::visitMultiplicativeExpr(MultiplicativeExprNode *node) switch (opQueue.front().first) { case MultiplicativeExprNode::OP_MUL: - currentType = opRuleManager->getMulResultType(operand->codeLoc, currentType, operandType); + currentType = opRuleManager->getMulResultType(operand, currentType, operandType); break; case MultiplicativeExprNode::OP_DIV: currentType = opRuleManager->getDivResultType(operand->codeLoc, currentType, operandType); @@ -2017,9 +2017,12 @@ std::any AnalyzerVisitor::visitFunctionCall(FunctionCallNode *node) { if (!accessScope->isImported(currentScope) && spiceFunc->getDeclCodeLoc().line < node->codeLoc.line) reAnalyzeRequired = true; - // Return struct type on constructor call - if (constructorCall) + if (constructorCall) { + // Add anonymous symbol to keep track of de-allocation + currentScope->insertAnonymous(thisType, node); + // Return struct type on constructor call return node->setEvaluatedSymbolType(thisType); + } // If the callee is a procedure, return type bool if (spiceFunc->isProcedure() || spiceFunc->getReturnType().is(TY_DYN)) @@ -2167,6 +2170,9 @@ std::any AnalyzerVisitor::visitStructInstantiation(StructInstantiationNode *node } } + // Insert anonymous symbol to keep track of dtor calls for de-allocation + currentScope->insertAnonymous(structType, node); + return node->setEvaluatedSymbolType(structType); } @@ -2299,8 +2305,18 @@ std::any AnalyzerVisitor::visitCustomDataType(CustomDataTypeNode *node) { return node->setEvaluatedSymbolType(SymbolType(TY_STRUCT, identifier, {.arraySize = 0}, concreteTemplateTypes)); } +SymbolType AnalyzerVisitor::insertAnonStringStructSymbol(const AstNode *declNode) { + SymbolType stringStructType(TY_STRING, "", {.isStringStruct = true}, {}); + currentScope->insertAnonymous(stringStructType, declNode); + return stringStructType; +} + void AnalyzerVisitor::insertDestructorCall(const CodeLoc &codeLoc, SymbolTableEntry *varEntry) { - assert(varEntry != nullptr && varEntry->getType().is(TY_STRUCT)); + assert(varEntry != nullptr); + SymbolType varEntryType = varEntry->getType(); + if (varEntryType.isStringStruct()) + return; + assert(varEntryType.is(TY_STRUCT)); // Create Spice function for destructor SymbolTableEntry *structEntry = currentScope->lookup(varEntry->getType().getName()); @@ -2309,7 +2325,9 @@ void AnalyzerVisitor::insertDestructorCall(const CodeLoc &codeLoc, SymbolTableEn accessScope = accessScope->getChild(STRUCT_SCOPE_PREFIX + structEntry->getName()); assert(accessScope != nullptr); SymbolType thisType = varEntry->getType(); - accessScope->matchFunction(currentScope, DTOR_VARIABLE_NAME, thisType, {}, codeLoc); + Function *spiceFunc = accessScope->matchFunction(currentScope, DTOR_VARIABLE_NAME, thisType, {}, codeLoc); + if (spiceFunc) + spiceFunc->setUsed(); } SymbolType AnalyzerVisitor::initExtStruct(SymbolTable *sourceScope, const std::string &structScopePrefix, diff --git a/src/analyzer/AnalyzerVisitor.h b/src/analyzer/AnalyzerVisitor.h index 63e7222cc..db26cb5db 100644 --- a/src/analyzer/AnalyzerVisitor.h +++ b/src/analyzer/AnalyzerVisitor.h @@ -22,7 +22,7 @@ const std::string DTOR_VARIABLE_NAME = "dtor"; const std::string STRUCT_SCOPE_PREFIX = "struct:"; const std::string ENUM_SCOPE_PREFIX = "enum:"; const std::string UNUSED_VARIABLE_NAME = "_"; -const std::vector RESERVED_KEYWORDS = {"new", "switch", "case", "yield", "stash", "pick", "sync"}; +const std::vector RESERVED_KEYWORDS = {"new", "switch", "case", "yield", "stash", "pick", "sync", "class"}; // Forward declarations class OpRuleManager; @@ -50,6 +50,9 @@ class AnalyzerVisitor : public AstVisitor { const ThreadFactory &threadFactory, const SourceFile &sourceFile, CliOptions &options, bool requiresMainFct, bool stdFile); + // Friend classes + friend class OpRuleManager; + // Public methods std::any visitEntry(EntryNode *node) override; std::any visitMainFctDef(MainFctDefNode *node) override; @@ -126,6 +129,7 @@ class AnalyzerVisitor : public AstVisitor { bool allowUnsafeOperations = false; // Private methods + SymbolType insertAnonStringStructSymbol(const AstNode *declNode); void insertDestructorCall(const CodeLoc &codeLoc, SymbolTableEntry *varEntry); SymbolType initExtStruct(SymbolTable *sourceScope, const std::string &structScopePrefix, const std::string &structName, const std::vector &templateTypes, const CodeLoc &codeLoc); diff --git a/src/analyzer/OpRuleManager.cpp b/src/analyzer/OpRuleManager.cpp index eb6eb021f..6120154c3 100644 --- a/src/analyzer/OpRuleManager.cpp +++ b/src/analyzer/OpRuleManager.cpp @@ -2,6 +2,9 @@ #include "OpRuleManager.h" +#include +#include + SymbolType OpRuleManager::getAssignResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { // Skip type compatibility check if the lhs is of type dyn -> perform type inference if (lhs.is(TY_DYN)) @@ -22,27 +25,27 @@ SymbolType OpRuleManager::getAssignResultType(const CodeLoc &codeLoc, const Symb return validateBinaryOperation(codeLoc, ASSIGN_OP_RULES, "=", lhs, rhs); } -SymbolType OpRuleManager::getPlusEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { +SymbolType OpRuleManager::getPlusEqualResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs) { if (lhs.isPointer() && rhs.isOneOf({TY_INT, TY_LONG, TY_SHORT})) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return lhs; else - throw printErrorMessageUnsafe(codeLoc, "+=", lhs, rhs); + throw printErrorMessageUnsafe(declNode->codeLoc, "+=", lhs, rhs); } // Allow string += char if (lhs.is(TY_STRING) && rhs.is(TY_CHAR)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + return analyzer->insertAnonStringStructSymbol(declNode); // Allow string += string if (lhs.is(TY_STRING) && rhs.is(TY_STRING)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + return analyzer->insertAnonStringStructSymbol(declNode); - return validateBinaryOperation(codeLoc, PLUS_EQUAL_OP_RULES, "+=", lhs, rhs); + return validateBinaryOperation(declNode->codeLoc, PLUS_EQUAL_OP_RULES, "+=", lhs, rhs); } SymbolType OpRuleManager::getMinusEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { if (lhs.isPointer() && rhs.isOneOf({TY_INT, TY_LONG, TY_SHORT})) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return lhs; else throw printErrorMessageUnsafe(codeLoc, "-=", lhs, rhs); @@ -51,18 +54,18 @@ SymbolType OpRuleManager::getMinusEqualResultType(const CodeLoc &codeLoc, const return validateBinaryOperation(codeLoc, MINUS_EQUAL_OP_RULES, "-=", lhs, rhs); } -SymbolType OpRuleManager::getMulEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { +SymbolType OpRuleManager::getMulEqualResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs) { // Allow string *= int if (lhs.is(TY_STRING) && rhs.is(TY_INT)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + return analyzer->insertAnonStringStructSymbol(declNode); // Allow string *= long if (lhs.is(TY_STRING) && rhs.is(TY_LONG)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + return analyzer->insertAnonStringStructSymbol(declNode); // Allow string *= short if (lhs.is(TY_STRING) && rhs.is(TY_SHORT)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + return analyzer->insertAnonStringStructSymbol(declNode); - return validateBinaryOperation(codeLoc, MUL_EQUAL_OP_RULES, "*=", lhs, rhs); + return validateBinaryOperation(declNode->codeLoc, MUL_EQUAL_OP_RULES, "*=", lhs, rhs); } SymbolType OpRuleManager::getDivEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { @@ -159,40 +162,45 @@ SymbolType OpRuleManager::getShiftRightResultType(const CodeLoc &codeLoc, const return validateBinaryOperation(codeLoc, SHIFT_RIGHT_OP_RULES, ">>", lhs, rhs); } -SymbolType OpRuleManager::getPlusResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { +SymbolType OpRuleManager::getPlusResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs) { // Allow any* + if (lhs.isPointer() && rhs.isOneOf({TY_INT, TY_LONG, TY_SHORT})) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return lhs; else - throw printErrorMessageUnsafe(codeLoc, "+", lhs, rhs); + throw printErrorMessageUnsafe(declNode->codeLoc, "+", lhs, rhs); } // Allow + any* if (lhs.isOneOf({TY_INT, TY_LONG, TY_SHORT}) && rhs.isPointer()) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return rhs; else - throw printErrorMessageUnsafe(codeLoc, "+", lhs, rhs); + throw printErrorMessageUnsafe(declNode->codeLoc, "+", lhs, rhs); } // Allow string + string - if (lhs.is(TY_STRING) && rhs.is(TY_STRING)) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + if (lhs.is(TY_STRING) && rhs.is(TY_STRING)) { + if (!lhs.isStringStruct() && !rhs.isStringStruct()) { // If lhs and rhs are raw strings -> insert anon symbol + return analyzer->insertAnonStringStructSymbol(declNode); + } else { // Otherwise just return the type + return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + } + } - return validateBinaryOperation(codeLoc, PLUS_OP_RULES, "+", lhs, rhs); + return validateBinaryOperation(declNode->codeLoc, PLUS_OP_RULES, "+", lhs, rhs); } SymbolType OpRuleManager::getMinusResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { // Allow any* - if (lhs.isPointer() && rhs.isOneOf({TY_INT, TY_LONG, TY_SHORT})) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return lhs; else throw printErrorMessageUnsafe(codeLoc, "-", lhs, rhs); } // Allow - any* if (lhs.isOneOf({TY_INT, TY_LONG, TY_SHORT}) && rhs.isPointer()) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return rhs; else throw printErrorMessageUnsafe(codeLoc, "-", lhs, rhs); @@ -201,32 +209,26 @@ SymbolType OpRuleManager::getMinusResultType(const CodeLoc &codeLoc, const Symbo return validateBinaryOperation(codeLoc, MINUS_OP_RULES, "-", lhs, rhs); } -SymbolType OpRuleManager::getMulResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { - // Allow string * int and int * string - if ((lhs.is(TY_STRING) && rhs.is(TY_INT)) || (lhs.is(TY_INT) && rhs.is(TY_STRING))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); - - // Allow string * short and short * string - if ((lhs.is(TY_STRING) && rhs.is(TY_SHORT)) || (lhs.is(TY_SHORT) && rhs.is(TY_STRING))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); - - // Allow string * long and long * string - if ((lhs.is(TY_STRING) && rhs.is(TY_LONG)) || (lhs.is(TY_LONG) && rhs.is(TY_STRING))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); - - // Allow char * int and int * char - if ((lhs.is(TY_CHAR) && rhs.is(TY_INT)) || (lhs.is(TY_INT) && rhs.is(TY_CHAR))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); - - // Allow char * short and short * char - if ((lhs.is(TY_CHAR) && rhs.is(TY_SHORT)) || (lhs.is(TY_SHORT) && rhs.is(TY_CHAR))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); +SymbolType OpRuleManager::getMulResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs) { + // Allow * + if (lhs.isOneOf({TY_STRING, TY_CHAR}) && rhs.isOneOf({TY_INT, TY_SHORT, TY_LONG})) { + if (!lhs.isStringStruct()) { // If lhs is a raw string -> insert anon symbol + return analyzer->insertAnonStringStructSymbol(declNode); + } else { // Otherwise just return the type + return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + } + } - // Allow char * long and long * char - if ((lhs.is(TY_CHAR) && rhs.is(TY_LONG)) || (lhs.is(TY_LONG) && rhs.is(TY_CHAR))) - return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + // Allow * + if (lhs.isOneOf({TY_INT, TY_SHORT, TY_LONG}) && rhs.isOneOf({TY_STRING, TY_CHAR})) { + if (!rhs.isStringStruct()) { // If rhs is a raw string -> insert anon symbol + return analyzer->insertAnonStringStructSymbol(declNode); + } else { // Otherwise just return the type + return SymbolType(TY_STRING, "", {.isStringStruct = true}, {}); + } + } - return validateBinaryOperation(codeLoc, MUL_OP_RULES, "*", lhs, rhs); + return validateBinaryOperation(declNode->codeLoc, MUL_OP_RULES, "*", lhs, rhs); } SymbolType OpRuleManager::getDivResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs) { @@ -285,7 +287,7 @@ SymbolType OpRuleManager::getCastResultType(const CodeLoc &codeLoc, const Symbol return lhs; // Allow casts any* -> any* if (lhs.isPointer() && rhs.isPointer()) { - if (withinUnsafeBlock) + if (analyzer->allowUnsafeOperations) return lhs; else throw printErrorMessageUnsafe(codeLoc, "(cast)", lhs, rhs); diff --git a/src/analyzer/OpRuleManager.h b/src/analyzer/OpRuleManager.h index c6699319f..30ead1f67 100644 --- a/src/analyzer/OpRuleManager.h +++ b/src/analyzer/OpRuleManager.h @@ -9,6 +9,10 @@ #include #include +// Forward declarations +struct AstNode; +class AnalyzerVisitor; + // Types: double, int, short, long, byte, char, string, bool // Unary operator rule pair: lhs type, result type, unsafe @@ -565,13 +569,13 @@ const std::vector CAST_OP_RULES = { class OpRuleManager { public: // Constructors - explicit OpRuleManager(const bool &isUnsafe) : withinUnsafeBlock(isUnsafe) {} + explicit OpRuleManager(AnalyzerVisitor *analyzer) : analyzer(analyzer) {} // Public methods SymbolType getAssignResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); - SymbolType getPlusEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); + SymbolType getPlusEqualResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs); SymbolType getMinusEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); - SymbolType getMulEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); + SymbolType getMulEqualResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs); SymbolType getDivEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getRemEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getSHLEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); @@ -592,9 +596,9 @@ class OpRuleManager { SymbolType getGreaterEqualResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getShiftLeftResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getShiftRightResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); - SymbolType getPlusResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); + SymbolType getPlusResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs); SymbolType getMinusResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); - SymbolType getMulResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); + SymbolType getMulResultType(const AstNode *declNode, const SymbolType &lhs, const SymbolType &rhs); SymbolType getDivResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getRemResultType(const CodeLoc &codeLoc, const SymbolType &lhs, const SymbolType &rhs); SymbolType getPrefixMinusResultType(const CodeLoc &codeLoc, const SymbolType &lhs); @@ -610,7 +614,7 @@ class OpRuleManager { private: // Members - const bool &withinUnsafeBlock; + AnalyzerVisitor *analyzer; // Private methods SymbolType validateBinaryOperation(const CodeLoc &codeLoc, const std::vector &opRules, const std::string &opName, diff --git a/src/cli/CliInterface.cpp b/src/cli/CliInterface.cpp index 59faa5eb7..fb99d66ab 100644 --- a/src/cli/CliInterface.cpp +++ b/src/cli/CliInterface.cpp @@ -370,5 +370,7 @@ void CliInterface::runBinary() const { std::cout << "Running executable ...\n\n"; // Run executable - std::system(cliOptions.outputPath.c_str()); + int exitCode = std::system(cliOptions.outputPath.c_str()) / 256; + if (exitCode != 0) + throw CliError(NON_ZERO_EXIT_CODE, "Your Spice executable exited with non-zero exit code " + std::to_string(exitCode)); } \ No newline at end of file diff --git a/src/dependency/SourceFile.cpp b/src/dependency/SourceFile.cpp index 343b1d040..b88a4d620 100644 --- a/src/dependency/SourceFile.cpp +++ b/src/dependency/SourceFile.cpp @@ -95,7 +95,7 @@ void SourceFile::visualizeCST(std::string *output) { std::cout << "\nGenerating SVG file ... "; std::string fileBasePath = options.outputDir + FileUtil::DIR_SEPARATOR + "cst"; FileUtil::writeToFile(fileBasePath + ".dot", dotCode); - std::string cmdResult = FileUtil::exec("dot -Tsvg -o" + fileBasePath + ".svg " + fileBasePath + ".dot"); + FileUtil::exec("dot -Tsvg -o" + fileBasePath + ".svg " + fileBasePath + ".dot"); std::cout << "done.\nSVG file can be found at: " << fileBasePath << ".svg\n"; } } @@ -149,7 +149,7 @@ void SourceFile::visualizeAST(std::string *output) { std::cout << "\nGenerating SVG file ... "; std::string fileBasePath = options.outputDir + FileUtil::DIR_SEPARATOR + "ast"; FileUtil::writeToFile(fileBasePath + ".dot", dotCode); - std::string cmdResult = FileUtil::exec("dot -Tsvg -o" + fileBasePath + ".svg " + fileBasePath + ".dot"); + FileUtil::exec("dot -Tsvg -o" + fileBasePath + ".svg " + fileBasePath + ".dot"); std::cout << "done.\nSVG file can be found at: " << fileBasePath << ".svg\n"; } } diff --git a/src/exception/CliError.cpp b/src/exception/CliError.cpp index c53835ff6..94094f842 100644 --- a/src/exception/CliError.cpp +++ b/src/exception/CliError.cpp @@ -34,6 +34,8 @@ std::string CliError::getMessagePrefix(CliErrorType type) { return "Source file missing"; case OPT_DEBUG_INFO_INCOMPATIBILITY: return "Cannot emit debug info with optimization enabled"; + case NON_ZERO_EXIT_CODE: + return "Non-zero exit code"; case COMING_SOON_CLI: return "Coming soon"; } diff --git a/src/exception/CliError.h b/src/exception/CliError.h index 7589439b1..d23604cc7 100644 --- a/src/exception/CliError.h +++ b/src/exception/CliError.h @@ -10,6 +10,7 @@ enum CliErrorType { INVALID_TARGET_TRIPLE, SOURCE_FILE_MISSING, OPT_DEBUG_INFO_INCOMPATIBILITY, + NON_ZERO_EXIT_CODE, COMING_SOON_CLI, }; diff --git a/src/exception/LinkerError.cpp b/src/exception/LinkerError.cpp index 71a36d6bb..92f6360a8 100644 --- a/src/exception/LinkerError.cpp +++ b/src/exception/LinkerError.cpp @@ -28,6 +28,8 @@ std::string LinkerError::getMessagePrefix(LinkerErrorType type) { switch (type) { case LINKER_NOT_FOUND: return "Linker not found"; + case LINKER_ERROR: + return "Linker error occurred"; } return "Unknown error"; // GCOV_EXCL_LINE } \ No newline at end of file diff --git a/src/exception/LinkerError.h b/src/exception/LinkerError.h index 01bee6a00..6d5671c22 100644 --- a/src/exception/LinkerError.h +++ b/src/exception/LinkerError.h @@ -6,6 +6,7 @@ enum LinkerErrorType { LINKER_NOT_FOUND, + LINKER_ERROR, }; /** diff --git a/src/generator/GeneratorVisitor.cpp b/src/generator/GeneratorVisitor.cpp index c7d37f25c..f58563382 100644 --- a/src/generator/GeneratorVisitor.cpp +++ b/src/generator/GeneratorVisitor.cpp @@ -1308,7 +1308,7 @@ std::any GeneratorVisitor::visitAssertStmt(AssertStmtNode *node) { builder->CreateCall(printfFct, templateString); // Generate call to exit llvm::Function *exitFct = stdFunctionManager->getExitFct(); - builder->CreateCall(exitFct, builder->getInt32(1)); + builder->CreateCall(exitFct, builder->getInt32(0)); // Create unreachable instruction builder->CreateUnreachable(); @@ -1464,20 +1464,17 @@ std::any GeneratorVisitor::visitPrintfCall(PrintfCallNode *node) { printfArgs.push_back(builder->CreateGlobalStringPtr(node->templatedString)); for (const auto &arg : node->assignExpr()) { SymbolType argSymbolType = arg->getEvaluatedSymbolType(); - - // Visit argument - llvm::Value *argValPtr = resolveAddress(arg); llvm::Type *targetType = argSymbolType.toLLVMType(*context, currentScope); llvm::Value *argVal; if (argSymbolType.isArray()) { // Convert array type to pointer type + llvm::Value *argValPtr = resolveAddress(arg); llvm::Value *indices[2] = {builder->getInt32(0), builder->getInt32(0)}; argVal = builder->CreateInBoundsGEP(targetType, argValPtr, indices); } else if (argSymbolType.isStringStruct()) { - argValPtr = materializeString(argValPtr); - argVal = builder->CreateLoad(targetType, argValPtr); + argVal = materializeString(resolveAddress(arg)); } else { - argVal = builder->CreateLoad(targetType, argValPtr); + argVal = resolveValue(arg); } // Cast all integer types to 32 bit @@ -1644,15 +1641,16 @@ std::any GeneratorVisitor::visitAssignExpr(AssignExprNode *node) { } // Decide what to do, based on the operator + PtrAndValue result = {nullptr, nullptr}; switch (node->op) { case AssignExprNode::OP_PLUS_EQUAL: - rhs = conversionsManager->getPlusEqualInst(lhs, rhs, lhsTy, rhsTy, currentScope, node->codeLoc); + result = conversionsManager->getPlusEqualInst({lhsPtr, lhs}, rhs, lhsTy, rhsTy, currentScope, node->codeLoc); break; case AssignExprNode::OP_MINUS_EQUAL: rhs = conversionsManager->getMinusEqualInst(lhs, rhs, lhsTy, rhsTy, currentScope); break; case AssignExprNode::OP_MUL_EQUAL: - rhs = conversionsManager->getMulEqualInst(lhs, rhs, lhsTy, rhsTy); + result = conversionsManager->getMulEqualInst({lhsPtr, lhs}, rhs, lhsTy, rhsTy, currentScope, node->codeLoc); break; case AssignExprNode::OP_DIV_EQUAL: rhs = conversionsManager->getDivEqualInst(lhs, rhs, lhsTy, rhsTy); @@ -1678,6 +1676,14 @@ std::any GeneratorVisitor::visitAssignExpr(AssignExprNode *node) { default: throw std::runtime_error("Assign op fall-through"); } + + if (result.ptr) { + variableEntry->updateAddress(result.ptr); + return result.ptr; + } + if (result.value) + rhs = result.value; + builder->CreateStore(rhs, lhsPtr, variableEntry->isVolatile()); } @@ -1983,17 +1989,20 @@ std::any GeneratorVisitor::visitAdditiveExpr(AdditiveExprNode *node) { MultiplicativeExprNode *rhsOperand = node->operands()[operandIndex++]; assert(rhsOperand != nullptr); SymbolType rhsSymbolType = rhsOperand->getEvaluatedSymbolType(); - llvm::Value *rhs = resolveValue(rhsOperand); + llvm::Value *rhs; + PtrAndValue result = {nullptr, nullptr}; switch (opQueue.front().first) { case AdditiveExprNode::OP_PLUS: - /*if (lhsSymbolType.isStringStruct()) - lhs = materializeString(lhsPtr); - if (rhsSymbolType.isStringStruct()) - rhs = materializeString(rhsPtr);*/ - lhs = conversionsManager->getPlusInst(lhs, rhs, lhsSymbolType, rhsSymbolType, currentScope, node->codeLoc); + if (rhsSymbolType.isStringStruct()) { + rhs = materializeString(resolveAddress(rhsOperand)); + } else { + rhs = resolveValue(rhsOperand); + } + result = conversionsManager->getPlusInst(lhs, rhs, lhsSymbolType, rhsSymbolType, currentScope, rhsOperand->codeLoc); break; case AdditiveExprNode::OP_MINUS: + rhs = resolveValue(rhsOperand); lhs = conversionsManager->getMinusInst(lhs, rhs, lhsSymbolType, rhsSymbolType, currentScope); break; default: @@ -2001,6 +2010,13 @@ std::any GeneratorVisitor::visitAdditiveExpr(AdditiveExprNode *node) { } lhsSymbolType = opQueue.front().second; + + if (result.ptr) { + lhs = builder->CreateLoad(lhsSymbolType.toLLVMType(*context, currentScope), result.ptr); + } else if (result.value) { + lhs = result.value; + } + opQueue.pop(); } @@ -2020,6 +2036,8 @@ std::any GeneratorVisitor::visitMultiplicativeExpr(MultiplicativeExprNode *node) SymbolType lhsSymbolType = lhsOperand->getEvaluatedSymbolType(); llvm::Value *lhs = resolveValue(lhsOperand); + llvm::Value *resultPtr = nullptr; + auto opQueue = node->opQueue; size_t operandIndex = 1; while (!opQueue.empty()) { @@ -2028,10 +2046,15 @@ std::any GeneratorVisitor::visitMultiplicativeExpr(MultiplicativeExprNode *node) SymbolType rhsSymbolType = rhsOperand->getEvaluatedSymbolType(); llvm::Value *rhs = resolveValue(rhsOperand); + PtrAndValue result = {nullptr, nullptr}; switch (opQueue.front().first) { - case MultiplicativeExprNode::OP_MUL: - lhs = conversionsManager->getMulInst(lhs, rhs, lhsSymbolType, rhsSymbolType, node->codeLoc); + case MultiplicativeExprNode::OP_MUL: { + llvm::Value *lhsPtr = resultPtr ?: resolveAddress(lhsOperand); + llvm::Value *rhsPtr = resolveAddress(rhsOperand); + result = conversionsManager->getMulInst({lhsPtr, lhs}, {rhsPtr, rhs}, lhsSymbolType, rhsSymbolType, currentScope, + rhsOperand->codeLoc); break; + } case MultiplicativeExprNode::OP_DIV: lhs = conversionsManager->getDivInst(lhs, rhs, lhsSymbolType, rhsSymbolType); break; @@ -2043,10 +2066,18 @@ std::any GeneratorVisitor::visitMultiplicativeExpr(MultiplicativeExprNode *node) } lhsSymbolType = opQueue.front().second; + + if (result.ptr) { + resultPtr = result.ptr; + lhs = builder->CreateLoad(lhsSymbolType.toLLVMType(*context, currentScope), resultPtr); + } else if (result.value) { + lhs = result.value; + } + opQueue.pop(); } - llvm::Value *resultPtr = insertAlloca(lhs->getType()); + resultPtr = resultPtr ?: insertAlloca(lhs->getType()); builder->CreateStore(lhs, resultPtr); return resultPtr; } @@ -2652,7 +2683,7 @@ std::any GeneratorVisitor::visitFunctionCall(FunctionCallNode *node) { SymbolType actualArgSymbolType = arg->getEvaluatedSymbolType(); llvm::Value *actualArgPtr = resolveAddress(arg); - // If the arrays are both of size -1 or 0, they are both pointers and do not need to be implicitly casted + // If the arrays are both of size -1 or 0, they are both pointers and do not need to be cast implicitly bool isSameArray = actualArgSymbolType.isArray() && expectedArgSymbolType.isArray() && actualArgSymbolType.getArraySize() <= 0 && expectedArgSymbolType.getArraySize() <= 0; @@ -2671,6 +2702,12 @@ std::any GeneratorVisitor::visitFunctionCall(FunctionCallNode *node) { // Consider constructor calls if (constructorCall) { + // Update mem-address of anonymous symbol + SymbolTableEntry *anonEntry = currentScope->lookupAnonymous(node->codeLoc); + assert(anonEntry != nullptr); + anonEntry->updateAddress(thisValuePtr); + + // Return pointer to this value return thisValuePtr; } else if (!resultValue->getType()->isSized()) { // Set return type bool for procedures @@ -2866,6 +2903,11 @@ std::any GeneratorVisitor::visitStructInstantiation(StructInstantiationNode *nod } } + // Update the address of the anonymous symbol + SymbolTableEntry *anonSymbol = currentScope->lookupAnonymous(node->codeLoc); + assert(anonSymbol != nullptr); + anonSymbol->updateAddress(structAddress); + return structAddress; } @@ -2966,9 +3008,10 @@ void GeneratorVisitor::createCondBr(llvm::Value *condition, llvm::BasicBlock *tr llvm::Value *GeneratorVisitor::insertAlloca(llvm::Type *llvmType, const std::string &varName) { if (allocaInsertInst != nullptr) { - allocaInsertInst = builder->CreateAlloca(llvmType, nullptr, varName); - allocaInsertInst->setDebugLoc(llvm::DebugLoc()); - allocaInsertInst->moveAfter(allocaInsertInst); + llvm::AllocaInst *allocaInst = builder->CreateAlloca(llvmType, nullptr, varName); + allocaInst->setDebugLoc(llvm::DebugLoc()); + allocaInst->moveAfter(allocaInsertInst); + allocaInsertInst = allocaInst; } else { // Save current basic block and move insert cursor to entry block of the current function llvm::BasicBlock *currentBlock = builder->GetInsertBlock(); @@ -3014,46 +3057,58 @@ llvm::Value *GeneratorVisitor::createGlobalArray(llvm::Constant *constArray) { } bool GeneratorVisitor::insertDestructorCall(const CodeLoc &codeLoc, SymbolTableEntry *varEntry) { - Function *spiceDtor = currentScope->getFunctionAccessPointer(codeLoc); - - // Cancel if no destructor was found - if (spiceDtor == nullptr) - return false; + if (varEntry->getType().isStringStruct()) { + // Get dtor function + llvm::Function *fct = stdFunctionManager->getStringDtorFct(); - // Get this value pointer - llvm::Value *thisValuePtr = varEntry->getAddress(); + // Get this value pointer + llvm::Value *thisValuePtr = varEntry->getAddress(); + assert(thisValuePtr != nullptr); - // Check if function exists in the current module - bool functionFound = false; - std::string fctIdentifier = spiceDtor->getMangledName(); - for (const auto &function : module->getFunctionList()) { // Search for function definition - if (function.getName() == fctIdentifier) { - functionFound = true; - break; - } else if (function.getName() == spiceDtor->getName()) { - functionFound = true; - fctIdentifier = spiceDtor->getName(); - break; + // Insert call + builder->CreateCall(fct, thisValuePtr); + } else { + Function *spiceDtor = currentScope->getFunctionAccessPointer(codeLoc); + + // Cancel if no destructor was found + if (spiceDtor == nullptr) + return false; + + // Get this value pointer + llvm::Value *thisValuePtr = varEntry->getAddress(); + + // Check if function exists in the current module + bool functionFound = false; + std::string mangledName = spiceDtor->getMangledName(); + for (const auto &function : module->getFunctionList()) { // Search for function definition + llvm::StringRef functionName = function.getName(); + if (functionName == mangledName) { + functionFound = true; + break; + } else if (functionName == spiceDtor->getName()) { + functionFound = true; + mangledName = spiceDtor->getName(); + break; + } } - } - if (!functionFound) { // Not found => Declare function, which will be linked in - llvm::FunctionType *fctType = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), thisValuePtr->getType(), false); - module->getOrInsertFunction(fctIdentifier, fctType); - } - - // Get the declared function and its type - llvm::Function *fct = module->getFunction(fctIdentifier); - assert(fct != nullptr); + if (!functionFound) { // Not found => Declare function, which will be linked in + llvm::FunctionType *fctType = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), thisValuePtr->getType(), false); + module->getOrInsertFunction(mangledName, fctType); + } - // Create the function call - builder->CreateCall(fct, thisValuePtr); + // Get the declared function and its type + llvm::Function *fct = module->getFunction(mangledName); + assert(fct != nullptr); + // Create the function call + builder->CreateCall(fct, thisValuePtr); + } return true; } llvm::Value *GeneratorVisitor::materializeString(llvm::Value *stringStructPtr) { - assert(stringStructPtr->getType()->isPointerTy()); + // assert(stringStructPtr->getType()->isPointerTy()); llvm::Value *rawStringValue = builder->CreateCall(stdFunctionManager->getStringGetRawFct(), stringStructPtr); return rawStringValue; } diff --git a/src/generator/OpRuleConversionsManager.cpp b/src/generator/OpRuleConversionsManager.cpp index 4ca934258..766ab34e3 100644 --- a/src/generator/OpRuleConversionsManager.cpp +++ b/src/generator/OpRuleConversionsManager.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include OpRuleConversionsManager::OpRuleConversionsManager(GeneratorVisitor *generator) : generator(generator) { @@ -15,1444 +16,1523 @@ OpRuleConversionsManager::OpRuleConversionsManager(GeneratorVisitor *generator) stdFunctionManager = generator->stdFunctionManager.get(); } -llvm::Value *OpRuleConversionsManager::getPlusEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, - const SymbolType &rhsSTy, SymbolTable *accessScope, - const CodeLoc &codeLoc) { - llvm::Type *lhsTy = lhs->getType(); +PtrAndValue OpRuleConversionsManager::getPlusEqualInst(const PtrAndValue &lhsData, llvm::Value *rhsV, const SymbolType &lhsSTy, + const SymbolType &rhsSTy, SymbolTable *accessScope, + const CodeLoc &codeLoc) { + // Unpack lhs + llvm::Value *lhsV = lhsData.value; + llvm::Value *lhsP = lhsData.ptr; + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFAdd(lhs, rhs); + return {.value = builder->CreateFAdd(lhsV, rhsV)}; case COMB(TY_INT, TY_INT): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsInt)}; } case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsShort)}; } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_SHORT, TY_LONG): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsShort)}; } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsLong)}; } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_STRING, TY_CHAR): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method append(char) of the String struct llvm::Function *opFct = stdFunctionManager->getStringAppendCharFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_STRING): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method append(string) of the String struct llvm::Function *opFct = stdFunctionManager->getStringAppendStringFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_PTR, TY_INT): // fallthrough case COMB(TY_PTR, TY_SHORT): // fallthrough case COMB(TY_PTR, TY_LONG): - return builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhs, rhs); + llvm::Type *elementTy = lhsSTy.getContainedTy().toLLVMType(*context, accessScope); + return {.value = builder->CreateGEP(elementTy, lhsV, rhsV)}; } throw std::runtime_error("Internal compiler error: Operator fallthrough: +="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getMinusEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getMinusEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy, SymbolTable *accessScope) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFSub(lhs, rhs); + return builder->CreateFSub(lhsV, rhsV); case COMB(TY_INT, TY_INT): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsInt); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsShort); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsShort); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_PTR, TY_INT): // fallthrough case COMB(TY_PTR, TY_SHORT): // fallthrough case COMB(TY_PTR, TY_LONG): - return builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhs, rhs); + llvm::Type *elementType = lhsSTy.getContainedTy().toLLVMType(*context, accessScope); + return builder->CreateGEP(elementType, lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: -="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getMulEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, - const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); +PtrAndValue OpRuleConversionsManager::getMulEqualInst(const PtrAndValue &lhsData, llvm::Value *rhsV, const SymbolType &lhsSTy, + const SymbolType &rhsSTy, SymbolTable *accessScope, + const CodeLoc &codeLoc) { + // Unpack lhs + llvm::Value *lhsV = lhsData.value; + llvm::Value *lhsP = lhsData.ptr; + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFMul(lhs, rhs); + return {.value = builder->CreateFMul(lhsV, rhsV)}; case COMB(TY_INT, TY_INT): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateMul(lhsV, rhsInt)}; } case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateMul(lhsV, rhsShort)}; } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_SHORT, TY_LONG): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateMul(lhsV, rhsShort)}; } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateMul(lhsV, rhsLong)}; } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_STRING, TY_INT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method append(char) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpIntFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_LONG): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method append(char) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpLongFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_SHORT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method append(char) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpShortFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } } throw std::runtime_error("Internal compiler error: Operator fallthrough: *="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getDivEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getDivEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFDiv(lhs, rhs); + return builder->CreateFDiv(lhsV, rhsV); case COMB(TY_INT, TY_INT): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSDiv(lhsV, rhsInt); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSDiv(lhsV, rhsShort); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSDiv(lhsV, rhsShort); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSDiv(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: /="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getRemEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getRemEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFRem(lhs, rhs); + return builder->CreateFRem(lhsV, rhsV); case COMB(TY_INT, TY_INT): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSRem(lhsV, rhsInt); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSRem(lhsV, rhsShort); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSRem(lhsV, rhsShort); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSRem(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: %="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getSHLEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getSHLEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateShl(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateShl(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateShl(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateShl(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: <<="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getSHREqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getSHREqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateLShr(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateLShr(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateLShr(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateLShr(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: >>="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getAndEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getAndEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateAnd(lhs, rhs); + return builder->CreateAnd(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAnd(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateAnd(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateAnd(lhs, rhs); + return builder->CreateAnd(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAnd(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateAnd(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateAnd(lhs, rhs); + return builder->CreateAnd(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: &="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getOrEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getOrEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateOr(lhs, rhs); + return builder->CreateOr(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateOr(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateOr(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateOr(lhs, rhs); + return builder->CreateOr(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateOr(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateOr(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateOr(lhs, rhs); + return builder->CreateOr(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: |="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getXorEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getXorEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateXor(lhs, rhs); + return builder->CreateXor(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateXor(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateXor(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateXor(lhs, rhs); + return builder->CreateXor(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateXor(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateXor(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateXor(lhs, rhs); + return builder->CreateXor(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: ^="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getBitwiseAndInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getBitwiseAndInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): // fallthrough case COMB(TY_SHORT, TY_SHORT): // fallthrough case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateAnd(lhs, rhs); + return builder->CreateAnd(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: &"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getBitwiseOrInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getBitwiseOrInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): // fallthrough case COMB(TY_SHORT, TY_SHORT): // fallthrough case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateOr(lhs, rhs); + return builder->CreateOr(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: |"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getBitwiseXorInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getBitwiseXorInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): // fallthrough case COMB(TY_SHORT, TY_SHORT): // fallthrough case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): - return builder->CreateXor(lhs, rhs); + return builder->CreateXor(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: ^"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy, const CodeLoc &codeLoc) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsVTy = rhsV->getType(); // Check if both values are of type pointer - if (lhsTy->isPointerTy() && rhsTy->isPointerTy()) - return builder->CreateICmpEQ(lhs, rhs); + if (lhsVTy->isPointerTy() && rhsVTy->isPointerTy()) + return builder->CreateICmpEQ(lhsV, rhsV); // Check if one value is of type pointer and one is of type byte - if (lhsTy->isPointerTy() && rhsTy->isIntegerTy(32)) { - llvm::Value *lhsInt = builder->CreatePtrToInt(lhs, rhsTy); - return builder->CreateICmpEQ(lhsInt, rhs); + if (lhsVTy->isPointerTy() && rhsVTy->isIntegerTy(32)) { + llvm::Value *lhsInt = builder->CreatePtrToInt(lhsV, rhsVTy); + return builder->CreateICmpEQ(lhsInt, rhsV); } // Check for primitive type combinations switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpOEQ(lhs, rhs); + return builder->CreateFCmpOEQ(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpOEQ(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpOEQ(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOEQ(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOEQ(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpEQ(lhs, rhs); + return builder->CreateICmpEQ(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpEQ(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpEQ(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsLong, rhsV); } case COMB(TY_INT, TY_BYTE): // fallthrough case COMB(TY_INT, TY_CHAR): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpEQ(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpEQ(lhsV, rhsInt); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOEQ(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOEQ(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpEQ(lhs, rhs); + return builder->CreateICmpEQ(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsLong, rhsV); } case COMB(TY_SHORT, TY_BYTE): // fallthrough case COMB(TY_SHORT, TY_CHAR): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpEQ(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpEQ(lhsV, rhsShort); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOEQ(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOEQ(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpEQ(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpEQ(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): - return builder->CreateICmpEQ(lhs, rhs); + return builder->CreateICmpEQ(lhsV, rhsV); case COMB(TY_LONG, TY_BYTE): // fallthrough case COMB(TY_LONG, TY_CHAR): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpEQ(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpEQ(lhsV, rhsLong); } case COMB(TY_BYTE, TY_INT): // fallthrough case COMB(TY_CHAR, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsInt, rhsV); } case COMB(TY_BYTE, TY_SHORT): // fallthrough case COMB(TY_CHAR, TY_SHORT): { - llvm::Value *lhsShort = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsShort, rhs); + llvm::Value *lhsShort = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsShort, rhsV); } case COMB(TY_BYTE, TY_LONG): // fallthrough case COMB(TY_CHAR, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpEQ(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpEQ(lhsLong, rhsV); } case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpEQ(lhs, rhs); + return builder->CreateICmpEQ(lhsV, rhsV); case COMB(TY_STRING, TY_STRING): { // Generate call to the function isRawEqual(string, string) of the string std llvm::Function *opFct = stdFunctionManager->getStringIsRawEqualStringStringFct(); - llvm::Value *result = builder->CreateCall(opFct, {lhs, rhs}); + llvm::Value *result = builder->CreateCall(opFct, {lhsV, rhsV}); return result; } case COMB(TY_BOOL, TY_BOOL): - return builder->CreateICmpEQ(lhs, rhs); + return builder->CreateICmpEQ(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: =="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getNotEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getNotEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy, const CodeLoc &codeLoc) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsVTy = rhsV->getType(); // Check if both values are of type pointer - if (lhsTy->isPointerTy() && rhsTy->isPointerTy()) - return builder->CreateICmpNE(lhs, rhs); + if (lhsVTy->isPointerTy() && rhsVTy->isPointerTy()) + return builder->CreateICmpNE(lhsV, rhsV); // Check if one value is of type pointer and one is of type byte - if (lhsTy->isPointerTy() && rhsTy->isIntegerTy(32)) { - llvm::Value *lhsInt = builder->CreatePtrToInt(lhs, rhsTy); - return builder->CreateICmpNE(lhsInt, rhs); + if (lhsVTy->isPointerTy() && rhsVTy->isIntegerTy(32)) { + llvm::Value *lhsInt = builder->CreatePtrToInt(lhsV, rhsVTy); + return builder->CreateICmpNE(lhsInt, rhsV); } switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpONE(lhs, rhs); + return builder->CreateFCmpONE(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpONE(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpONE(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpONE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpONE(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpNE(lhs, rhs); + return builder->CreateICmpNE(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpNE(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpNE(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsLong, rhsV); } case COMB(TY_INT, TY_BYTE): // fallthrough case COMB(TY_INT, TY_CHAR): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpNE(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpNE(lhsV, rhsInt); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpONE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpONE(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpNE(lhs, rhs); + return builder->CreateICmpNE(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsLong, rhsV); } case COMB(TY_SHORT, TY_BYTE): // fallthrough case COMB(TY_SHORT, TY_CHAR): { - llvm::Value *rhsShort = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpNE(lhs, rhsShort); + llvm::Value *rhsShort = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpNE(lhsV, rhsShort); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpONE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpONE(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpNE(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpNE(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): - return builder->CreateICmpNE(lhs, rhs); + return builder->CreateICmpNE(lhsV, rhsV); case COMB(TY_LONG, TY_BYTE): // fallthrough case COMB(TY_LONG, TY_CHAR): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpNE(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpNE(lhsV, rhsLong); } case COMB(TY_BYTE, TY_INT): case COMB(TY_CHAR, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsInt, rhsV); } case COMB(TY_BYTE, TY_SHORT): // fallthrough case COMB(TY_CHAR, TY_SHORT): { - llvm::Value *lhsShort = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsShort, rhs); + llvm::Value *lhsShort = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsShort, rhsV); } case COMB(TY_BYTE, TY_LONG): // fallthrough case COMB(TY_CHAR, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpNE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpNE(lhsLong, rhsV); } case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpNE(lhs, rhs); + return builder->CreateICmpNE(lhsV, rhsV); case COMB(TY_STRING, TY_STRING): { // Generate call to the function isRawEqual(string, string) of the string std llvm::Function *opFct = stdFunctionManager->getStringIsRawEqualStringStringFct(); - llvm::Value *result = builder->CreateCall(opFct, {lhs, rhs}); + llvm::Value *result = builder->CreateCall(opFct, {lhsV, rhsV}); // Negate the result return builder->CreateNot(result); } case COMB(TY_BOOL, TY_BOOL): - return builder->CreateICmpNE(lhs, rhs); + return builder->CreateICmpNE(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: !="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getLessInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getLessInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + + // Unpack rhsV + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpOLT(lhs, rhs); + return builder->CreateFCmpOLT(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpOLT(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpOLT(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLT(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpSLT(lhs, rhs); + return builder->CreateICmpSLT(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSLT(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSLT(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLT(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLT(lhsLong, rhsV); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLT(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLT(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLT(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpSLT(lhs, rhs); + return builder->CreateICmpSLT(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLT(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLT(lhsLong, rhsV); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLT(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSLT(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSLT(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpSLT(lhs, rhs); + return builder->CreateICmpSLT(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: <"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getGreaterInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getGreaterInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpOGT(lhs, rhs); + return builder->CreateFCmpOGT(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpOGT(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpOGT(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGT(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpSGT(lhs, rhs); + return builder->CreateICmpSGT(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSGT(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSGT(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGT(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGT(lhsLong, rhsV); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGT(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGT(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGT(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpSGT(lhs, rhs); + return builder->CreateICmpSGT(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGT(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGT(lhsLong, rhsV); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGT(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGT(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSGT(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSGT(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpSGT(lhs, rhs); + return builder->CreateICmpSGT(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: >"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getLessEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getLessEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpOLE(lhs, rhs); + return builder->CreateFCmpOLE(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpOLE(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpOLE(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLE(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpSLE(lhs, rhs); + return builder->CreateICmpSLE(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSLE(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSLE(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLE(lhsLong, rhsV); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLE(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLE(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLE(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpSLE(lhs, rhs); + return builder->CreateICmpSLE(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSLE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSLE(lhsLong, rhsV); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOLE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOLE(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSLE(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSLE(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpSLE(lhs, rhs); + return builder->CreateICmpSLE(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: <="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getGreaterEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getGreaterEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhsV + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFCmpOGE(lhs, rhs); + return builder->CreateFCmpOGE(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFCmpOGE(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFCmpOGE(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGE(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateICmpSGE(lhs, rhs); + return builder->CreateICmpSGE(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSGE(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSGE(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGE(lhsLong, rhsV); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGE(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGE(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGE(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateICmpSGE(lhs, rhs); + return builder->CreateICmpSGE(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateICmpSGE(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateICmpSGE(lhsLong, rhsV); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFCmpOGE(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFCmpOGE(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateICmpSGE(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateICmpSGE(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateICmpSGE(lhs, rhs); + return builder->CreateICmpSGE(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: >="); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getShiftLeftInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getShiftLeftInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateShl(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateShl(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateShl(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateShl(lhsV, rhsInt); } case COMB(TY_LONG, TY_LONG): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); case COMB(TY_BYTE, TY_INT): // fallthrough case COMB(TY_BYTE, TY_SHORT): // fallthrough case COMB(TY_BYTE, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateShl(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateShl(lhsV, rhsInt); } case COMB(TY_BYTE, TY_BYTE): - return builder->CreateShl(lhs, rhs); + return builder->CreateShl(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: <<"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getShiftRightInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getShiftRightInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_INT, TY_INT): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_SHORT, TY_INT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateLShr(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateLShr(lhsV, rhsInt); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateLShr(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateLShr(lhsV, rhsInt); } case COMB(TY_LONG, TY_LONG): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); case COMB(TY_BYTE, TY_INT): // fallthrough case COMB(TY_BYTE, TY_SHORT): // fallthrough case COMB(TY_BYTE, TY_LONG): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateLShr(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateLShr(lhsV, rhsInt); } case COMB(TY_BYTE, TY_BYTE): - return builder->CreateLShr(lhs, rhs); + return builder->CreateLShr(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: >>"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPlusInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, - const SymbolType &rhsSTy, SymbolTable *accessScope, const CodeLoc &codeLoc) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); +PtrAndValue OpRuleConversionsManager::getPlusInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, + const SymbolType &rhsSTy, SymbolTable *accessScope, const CodeLoc &codeLoc) { + // Unpack lhs + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFAdd(lhs, rhs); + return {.value = builder->CreateFAdd(lhsV, rhsV)}; case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFAdd(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return {.value = builder->CreateFAdd(lhsV, rhsFP)}; } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFAdd(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return {.value = builder->CreateFAdd(lhsFP, rhsV)}; } case COMB(TY_INT, TY_INT): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsInt)}; } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateAdd(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return {.value = builder->CreateAdd(lhsLong, rhsV)}; } case COMB(TY_INT, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return {.value = builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV)}; case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFAdd(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return {.value = builder->CreateFAdd(lhsFP, rhsV)}; } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateAdd(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return {.value = builder->CreateAdd(lhsInt, rhsV)}; } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateAdd(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return {.value = builder->CreateAdd(lhsLong, rhsV)}; } case COMB(TY_SHORT, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return {.value = builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV)}; case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFAdd(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return {.value = builder->CreateFAdd(lhsFP, rhsV)}; } case COMB(TY_LONG, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateAdd(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return {.value = builder->CreateAdd(lhsInt, rhsV)}; } case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateAdd(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return {.value = builder->CreateAdd(lhsV, rhsLong)}; } case COMB(TY_LONG, TY_LONG): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_LONG, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return {.value = builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV)}; case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateAdd(lhs, rhs); + return {.value = builder->CreateAdd(lhsV, rhsV)}; case COMB(TY_STRING, TY_STRING): { // Generate call to the constructor ctor(string, string) of the String struct llvm::Function *opFct = stdFunctionManager->getStringCtorStringStringFct(); - llvm::Value *thisPtr = generator->insertAlloca(stdFunctionManager->getStringStructType()); - builder->CreateCall(opFct, {thisPtr, lhs, rhs}); - return thisPtr; + llvm::Value *thisPtr = generator->insertAlloca(StdFunctionManager::getStringStructType(*context)); + builder->CreateCall(opFct, {thisPtr, lhsV, rhsV}); + // Update mem address of anonymous symbol + SymbolTableEntry *anonEntry = accessScope->lookupAnonymous(codeLoc); + assert(anonEntry != nullptr); + anonEntry->updateAddress(thisPtr); + return {.ptr = thisPtr}; } case COMB(TY_PTR, TY_INT): // fallthrough case COMB(TY_PTR, TY_SHORT): // fallthrough case COMB(TY_PTR, TY_LONG): - return builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhs, rhs); + return {.value = builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhsV, rhsV)}; } throw std::runtime_error("Internal compiler error: Operator fallthrough: +"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getMinusInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getMinusInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy, SymbolTable *accessScope) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhsV + llvm::Type *lhsVTy = lhsV->getType(); + // Unpack rhsV + llvm::Type *rhsVTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFSub(lhs, rhs); + return builder->CreateFSub(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFSub(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsVTy); + return builder->CreateFSub(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFSub(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFSub(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSub(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateSub(lhsLong, rhsV); } case COMB(TY_INT, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV); case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFSub(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFSub(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSub(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateSub(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSub(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateSub(lhsLong, rhsV); } case COMB(TY_SHORT, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV); case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFSub(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsVTy); + return builder->CreateFSub(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSub(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsVTy, true); + return builder->CreateSub(lhsInt, rhsV); } case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSub(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsVTy, true); + return builder->CreateSub(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_LONG, TY_PTR): - return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhs, lhs); + return builder->CreateGEP(rhsSTy.getContainedTy().toLLVMType(*context, accessScope), rhsV, lhsV); case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateSub(lhs, rhs); + return builder->CreateSub(lhsV, rhsV); case COMB(TY_PTR, TY_INT): // fallthrough case COMB(TY_PTR, TY_SHORT): // fallthrough case COMB(TY_PTR, TY_LONG): - return builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhs, rhs); + return builder->CreateGEP(lhsSTy.getContainedTy().toLLVMType(*context, accessScope), lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: -"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getMulInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, - const SymbolType &rhsSTy, const CodeLoc &codeLoc) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); +PtrAndValue OpRuleConversionsManager::getMulInst(const PtrAndValue &lhsData, const PtrAndValue &rhsData, const SymbolType &lhsSTy, + const SymbolType &rhsSTy, SymbolTable *accessScope, const CodeLoc &codeLoc) { + // Unpack lhs + llvm::Value *lhsV = lhsData.value; + llvm::Value *lhsP = lhsData.ptr; + llvm::Type *lhsTy = lhsV->getType(); + // Unpack rhs + llvm::Value *rhsV = rhsData.value; + llvm::Value *rhsP = rhsData.ptr; + llvm::Type *rhsTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFMul(lhs, rhs); + return {.value = builder->CreateFMul(lhsV, rhsV)}; case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFMul(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsTy); + return {.value = builder->CreateFMul(lhsV, rhsFP)}; } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFMul(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return {.value = builder->CreateFMul(lhsFP, rhsV)}; } case COMB(TY_INT, TY_INT): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsTy, true); + return {.value = builder->CreateMul(lhsV, rhsInt)}; } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateMul(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return {.value = builder->CreateMul(lhsLong, rhsV)}; } case COMB(TY_INT, TY_CHAR): // fallthrough case COMB(TY_INT, TY_STRING): { - // Convert rhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(rhsSTy, rhs); + // Convert rhsV literal to string object if required + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, rhsSTy, rhsV, rhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpIntFct(); - builder->CreateCall(opFct, {thisPtr, lhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, lhsV}); + return {.ptr = thisPtr}; } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFMul(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return {.value = builder->CreateFMul(lhsFP, rhsV)}; } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateMul(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsTy, true); + return {.value = builder->CreateMul(lhsInt, rhsV)}; } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateMul(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return {.value = builder->CreateMul(lhsLong, rhsV)}; } case COMB(TY_SHORT, TY_CHAR): // fallthrough case COMB(TY_SHORT, TY_STRING): { - // Convert rhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(rhsSTy, rhs); + // Convert rhsV literal to string object if required + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, rhsSTy, rhsP, rhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpShortFct(); - builder->CreateCall(opFct, {thisPtr, lhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, lhsV}); + return {.ptr = thisPtr}; } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFMul(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return {.value = builder->CreateFMul(lhsFP, rhsV)}; } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateMul(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsTy, true); + return {.value = builder->CreateMul(lhsV, rhsLong)}; } case COMB(TY_LONG, TY_LONG): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_LONG, TY_CHAR): // fallthrough case COMB(TY_LONG, TY_STRING): { - // Convert rhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(rhsSTy, rhs); + // Convert rhsV literal to string object if required + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, rhsSTy, rhsP, rhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpLongFct(); - builder->CreateCall(opFct, {thisPtr, lhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, lhsV}); + return {.ptr = thisPtr}; } case COMB(TY_BYTE, TY_BYTE): - return builder->CreateMul(lhs, rhs); + return {.value = builder->CreateMul(lhsV, rhsV)}; case COMB(TY_CHAR, TY_INT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpIntFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_CHAR, TY_SHORT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpShortFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_CHAR, TY_LONG): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpLongFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_INT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpIntFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_SHORT): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpShortFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } case COMB(TY_STRING, TY_LONG): { // Convert lhs literal to string object if required - llvm::Value *thisPtr = propagateValueToStringObject(lhsSTy, lhs); + llvm::Value *thisPtr = propagateValueToStringObject(accessScope, lhsSTy, lhsP, lhsV, codeLoc); // Generate call to the method opMul(int) of the String struct llvm::Function *opFct = stdFunctionManager->getStringMulOpLongFct(); - builder->CreateCall(opFct, {thisPtr, rhs}); - return thisPtr; + builder->CreateCall(opFct, {thisPtr, rhsV}); + return {.ptr = thisPtr}; } } throw std::runtime_error("Internal compiler error: Operator fallthrough: *"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getDivInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getDivInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFDiv(lhs, rhs); + return builder->CreateFDiv(lhsV, rhsV); case COMB(TY_DOUBLE, TY_INT): // fallthrough case COMB(TY_DOUBLE, TY_SHORT): // fallthrough case COMB(TY_DOUBLE, TY_LONG): { - llvm::Value *rhsFP = builder->CreateSIToFP(rhs, lhsTy); - return builder->CreateFDiv(lhs, rhsFP); + llvm::Value *rhsFP = builder->CreateSIToFP(rhsV, lhsTy); + return builder->CreateFDiv(lhsV, rhsFP); } case COMB(TY_INT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFDiv(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return builder->CreateFDiv(lhsFP, rhsV); } case COMB(TY_INT, TY_INT): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsTy, true); + return builder->CreateSDiv(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSDiv(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSDiv(lhsLong, rhsV); } case COMB(TY_SHORT, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFDiv(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return builder->CreateFDiv(lhsFP, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSDiv(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSDiv(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSDiv(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSDiv(lhsLong, rhsV); } case COMB(TY_LONG, TY_DOUBLE): { - llvm::Value *lhsFP = builder->CreateSIToFP(lhs, rhsTy); - return builder->CreateFDiv(lhsFP, rhs); + llvm::Value *lhsFP = builder->CreateSIToFP(lhsV, rhsTy); + return builder->CreateFDiv(lhsFP, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSDiv(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsTy, true); + return builder->CreateSDiv(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): // fallthrough case COMB(TY_BYTE, TY_BYTE): // fallthrough case COMB(TY_CHAR, TY_CHAR): - return builder->CreateSDiv(lhs, rhs); + return builder->CreateSDiv(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: /"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getRemInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsSTy, +llvm::Value *OpRuleConversionsManager::getRemInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy) { - llvm::Type *lhsTy = lhs->getType(); - llvm::Type *rhsTy = rhs->getType(); + // Unpack lhs + llvm::Type *lhsTy = lhsV->getType(); + // Unpack rhs + llvm::Type *rhsTy = rhsV->getType(); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): - return builder->CreateFRem(lhs, rhs); + return builder->CreateFRem(lhsV, rhsV); case COMB(TY_INT, TY_INT): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); case COMB(TY_INT, TY_SHORT): { - llvm::Value *rhsInt = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsInt); + llvm::Value *rhsInt = builder->CreateIntCast(rhsV, lhsTy, true); + return builder->CreateSRem(lhsV, rhsInt); } case COMB(TY_INT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSRem(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSRem(lhsLong, rhsV); } case COMB(TY_SHORT, TY_INT): { - llvm::Value *lhsInt = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSRem(lhsInt, rhs); + llvm::Value *lhsInt = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSRem(lhsInt, rhsV); } case COMB(TY_SHORT, TY_SHORT): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); case COMB(TY_SHORT, TY_LONG): { - llvm::Value *lhsLong = builder->CreateIntCast(lhs, rhsTy, true); - return builder->CreateSRem(lhsLong, rhs); + llvm::Value *lhsLong = builder->CreateIntCast(lhsV, rhsTy, true); + return builder->CreateSRem(lhsLong, rhsV); } case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): { - llvm::Value *rhsLong = builder->CreateIntCast(rhs, lhsTy, true); - return builder->CreateSRem(lhs, rhsLong); + llvm::Value *rhsLong = builder->CreateIntCast(rhsV, lhsTy, true); + return builder->CreateSRem(lhsV, rhsLong); } case COMB(TY_LONG, TY_LONG): - return builder->CreateSRem(lhs, rhs); + return builder->CreateSRem(lhsV, rhsV); } throw std::runtime_error("Internal compiler error: Operator fallthrough: %"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPrefixMinusInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPrefixMinusInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_DOUBLE: - return builder->CreateFMul(lhs, llvm::ConstantFP::get(builder->getContext(), llvm::APFloat(double(-1)))); + return builder->CreateFMul(lhsV, llvm::ConstantFP::get(builder->getContext(), llvm::APFloat(double(-1)))); case TY_INT: // fallthrough case TY_SHORT: // fallthrough case TY_LONG: - return builder->CreateNeg(lhs); + return builder->CreateNeg(lhsV); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: +"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPrefixPlusPlusInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPrefixPlusPlusInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_INT: - return builder->CreateAdd(lhs, builder->getInt32(1)); + return builder->CreateAdd(lhsV, builder->getInt32(1)); case TY_SHORT: - return builder->CreateAdd(lhs, builder->getInt16(1)); + return builder->CreateAdd(lhsV, builder->getInt16(1)); case TY_LONG: - return builder->CreateAdd(lhs, builder->getInt64(1)); + return builder->CreateAdd(lhsV, builder->getInt64(1)); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: ++ (prefix)"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPrefixMinusMinusInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPrefixMinusMinusInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_INT: - return builder->CreateSub(lhs, builder->getInt32(1)); + return builder->CreateSub(lhsV, builder->getInt32(1)); case TY_SHORT: - return builder->CreateSub(lhs, builder->getInt16(1)); + return builder->CreateSub(lhsV, builder->getInt16(1)); case TY_LONG: - return builder->CreateSub(lhs, builder->getInt64(1)); + return builder->CreateSub(lhsV, builder->getInt64(1)); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: -- (prefix)"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPrefixNotInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPrefixNotInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_BOOL: - return builder->CreateNot(lhs); + return builder->CreateNot(lhsV); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: !"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPrefixBitwiseNotInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPrefixBitwiseNotInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_INT: // fallthrough case TY_SHORT: // fallthrough case TY_LONG: - return builder->CreateNeg(lhs); + return builder->CreateNeg(lhsV); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: ~"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPostfixPlusPlusInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPostfixPlusPlusInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_INT: - return builder->CreateAdd(lhs, builder->getInt32(1)); + return builder->CreateAdd(lhsV, builder->getInt32(1)); case TY_SHORT: - return builder->CreateAdd(lhs, builder->getInt16(1)); + return builder->CreateAdd(lhsV, builder->getInt16(1)); case TY_LONG: - return builder->CreateAdd(lhs, builder->getInt64(1)); + return builder->CreateAdd(lhsV, builder->getInt64(1)); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: ++ (postfix)"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getPostfixMinusMinusInst(llvm::Value *lhs, const SymbolType &lhsSTy) { +llvm::Value *OpRuleConversionsManager::getPostfixMinusMinusInst(llvm::Value *lhsV, const SymbolType &lhsSTy) { switch (lhsSTy.getSuperType()) { case TY_INT: - return builder->CreateSub(lhs, builder->getInt32(1)); + return builder->CreateSub(lhsV, builder->getInt32(1)); case TY_SHORT: - return builder->CreateSub(lhs, builder->getInt16(1)); + return builder->CreateSub(lhsV, builder->getInt16(1)); case TY_LONG: - return builder->CreateSub(lhs, builder->getInt64(1)); + return builder->CreateSub(lhsV, builder->getInt64(1)); default: break; } throw std::runtime_error("Internal compiler error: Operator fallthrough: -- (postfix)"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::getCastInst(llvm::Value *rhs, const SymbolType &lhsSTy, const SymbolType &rhsSTy, +llvm::Value *OpRuleConversionsManager::getCastInst(llvm::Value *rhsV, const SymbolType &lhsSTy, const SymbolType &rhsSTy, SymbolTable *accessScope) { + // Unpack lhs llvm::Type *lhsTy = lhsSTy.toLLVMType(*context, accessScope); + switch (COMB(lhsSTy.getSuperType(), rhsSTy.getSuperType())) { case COMB(TY_DOUBLE, TY_DOUBLE): // fallthrough case COMB(TY_INT, TY_INT): - return rhs; + return rhsV; case COMB(TY_INT, TY_SHORT): // fallthrough case COMB(TY_INT, TY_LONG): // fallthrough case COMB(TY_INT, TY_BYTE): // fallthrough case COMB(TY_INT, TY_CHAR): // fallthrough case COMB(TY_SHORT, TY_INT): - return builder->CreateIntCast(rhs, lhsTy, true); + return builder->CreateIntCast(rhsV, lhsTy, true); case COMB(TY_SHORT, TY_SHORT): - return rhs; + return rhsV; case COMB(TY_SHORT, TY_LONG): // fallthrough case COMB(TY_LONG, TY_INT): // fallthrough case COMB(TY_LONG, TY_SHORT): - return builder->CreateIntCast(rhs, lhsTy, true); + return builder->CreateIntCast(rhsV, lhsTy, true); case COMB(TY_LONG, TY_LONG): - return rhs; + return rhsV; case COMB(TY_BYTE, TY_INT): // fallthrough case COMB(TY_BYTE, TY_SHORT): // fallthrough case COMB(TY_BYTE, TY_LONG): - return builder->CreateIntCast(rhs, lhsTy, false); + return builder->CreateIntCast(rhsV, lhsTy, false); case COMB(TY_BYTE, TY_BYTE): - return rhs; + return rhsV; case COMB(TY_CHAR, TY_INT): // fallthrough case COMB(TY_CHAR, TY_SHORT): // fallthrough case COMB(TY_CHAR, TY_LONG): - return builder->CreateIntCast(rhs, lhsTy, false); + return builder->CreateIntCast(rhsV, lhsTy, false); case COMB(TY_CHAR, TY_CHAR): // fallthrough case COMB(TY_STRING, TY_STRING): - return rhs; + return rhsV; case COMB(TY_STRING, TY_PTR): - return builder->CreatePointerCast(rhs, lhsTy); + return builder->CreatePointerCast(rhsV, lhsTy); case COMB(TY_BOOL, TY_BOOL): - return rhs; + return rhsV; case COMB(TY_PTR, TY_STRING): // fallthrough (string corresponds to byte* or char*) case COMB(TY_PTR, TY_PTR): - return builder->CreatePointerCast(rhs, lhsTy); + return builder->CreatePointerCast(rhsV, lhsTy); } throw std::runtime_error("Internal compiler error: Operator fallthrough: (cast)"); // GCOV_EXCL_LINE } -llvm::Value *OpRuleConversionsManager::propagateValueToStringObject(const SymbolType &symbolType, llvm::Value *operandValue) { +llvm::Value *OpRuleConversionsManager::propagateValueToStringObject(SymbolTable *accessScope, const SymbolType &symbolType, + llvm::Value *operandPtr, llvm::Value *operandValue, + const CodeLoc &codeLoc) { if (symbolType.isStringStruct()) - return operandValue; + return operandPtr; assert(symbolType.isOneOf({TY_CHAR, TY_STRING})); // Convert rhs literal to string object llvm::Function *opFct = symbolType.is(TY_CHAR) ? stdFunctionManager->getStringCtorCharFct() : stdFunctionManager->getStringCtorStringFct(); - llvm::Value *thisPtr = generator->insertAlloca(stdFunctionManager->getStringStructType()); + llvm::Value *thisPtr = generator->insertAlloca(StdFunctionManager::getStringStructType(*context)); builder->CreateCall(opFct, {thisPtr, operandValue}); + // Update mem address of anonymous symbol + SymbolTableEntry *anonEntry = accessScope->lookupAnonymous(codeLoc); + assert(anonEntry != nullptr); + anonEntry->updateAddress(thisPtr); return thisPtr; -} \ No newline at end of file +} diff --git a/src/generator/OpRuleConversionsManager.h b/src/generator/OpRuleConversionsManager.h index 44d26c3e7..b7579d933 100644 --- a/src/generator/OpRuleConversionsManager.h +++ b/src/generator/OpRuleConversionsManager.h @@ -11,57 +11,67 @@ // Forward declarations class GeneratorVisitor; class StdFunctionManager; +class SymbolTable; struct CodeLoc; #define COMB(en1, en2) ((en1) | ((en2) << 16)) +// Helper struct for passing the pointer to the value and the value itself in parallel. +// The caller always has to provide both. If the PtrAndValue struct gets passed back, it either contains both data or only one +// and the other one is nullptr. +struct PtrAndValue { + llvm::Value *ptr = nullptr; + llvm::Value *value = nullptr; +}; + class OpRuleConversionsManager { public: // Constructors explicit OpRuleConversionsManager(GeneratorVisitor *generator); // Public methods - llvm::Value *getPlusEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, - SymbolTable *accessScope, const CodeLoc &codeLoc); + PtrAndValue getPlusEqualInst(const PtrAndValue &lhsData, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, + SymbolTable *accessScope, const CodeLoc &codeLoc); llvm::Value *getMinusEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, SymbolTable *accessScope); - llvm::Value *getMulEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getDivEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getRemEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getSHLEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getSHREqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getAndEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getOrEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getXorEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getBitwiseAndInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getBitwiseOrInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); + PtrAndValue getMulEqualInst(const PtrAndValue &lhsData, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, + SymbolTable *accessScope, const CodeLoc &codeLoc); + llvm::Value *getDivEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getRemEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getSHLEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getSHREqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getAndEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getOrEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getXorEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getBitwiseAndInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getBitwiseOrInst(llvm::Value *lhsV, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); llvm::Value *getBitwiseXorInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, + llvm::Value *getEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, const CodeLoc &codeLoc); - llvm::Value *getNotEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, + llvm::Value *getNotEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, const CodeLoc &codeLoc); - llvm::Value *getLessInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getGreaterInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getLessEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getGreaterEqualInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getShiftLeftInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getShiftRightInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getPlusInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, - SymbolTable *accessScope, const CodeLoc &codeLoc); - llvm::Value *getMinusInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, + llvm::Value *getLessInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getGreaterInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getLessEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getGreaterEqualInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getShiftLeftInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getShiftRightInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + PtrAndValue getPlusInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, + SymbolTable *accessScope, const CodeLoc &codeLoc); + llvm::Value *getMinusInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, SymbolTable *accessScope); - llvm::Value *getMulInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, - const CodeLoc &codeLoc); - llvm::Value *getDivInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getRemInst(llvm::Value *lhs, llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy); - llvm::Value *getPrefixMinusInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPrefixPlusPlusInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPrefixMinusMinusInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPrefixNotInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPrefixBitwiseNotInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPostfixPlusPlusInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getPostfixMinusMinusInst(llvm::Value *lhs, const SymbolType &lhsTy); - llvm::Value *getCastInst(llvm::Value *rhs, const SymbolType &lhsTy, const SymbolType &rhsTy, SymbolTable *accessScope); + PtrAndValue getMulInst(const PtrAndValue &lhsData, const PtrAndValue &rhsData, const SymbolType &lhsTy, const SymbolType &rhsTy, + SymbolTable *accessScope, const CodeLoc &codeLoc); + llvm::Value *getDivInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getRemInst(llvm::Value *lhsV, llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy); + llvm::Value *getPrefixMinusInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPrefixPlusPlusInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPrefixMinusMinusInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPrefixNotInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPrefixBitwiseNotInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPostfixPlusPlusInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getPostfixMinusMinusInst(llvm::Value *lhsV, const SymbolType &lhsTy); + llvm::Value *getCastInst(llvm::Value *rhsV, const SymbolType &lhsTy, const SymbolType &rhsTy, SymbolTable *accessScope); private: // Members @@ -71,5 +81,6 @@ class OpRuleConversionsManager { const StdFunctionManager *stdFunctionManager; // Private methods - llvm::Value *propagateValueToStringObject(const SymbolType &symbolType, llvm::Value *operandValue); + llvm::Value *propagateValueToStringObject(SymbolTable *accessScope, const SymbolType &symbolType, llvm::Value *operandPtr, + llvm::Value *operandValue, const CodeLoc &codeLoc); }; \ No newline at end of file diff --git a/src/generator/StdFunctionManager.cpp b/src/generator/StdFunctionManager.cpp index b2b2a6c5f..2f9b326d2 100644 --- a/src/generator/StdFunctionManager.cpp +++ b/src/generator/StdFunctionManager.cpp @@ -10,10 +10,14 @@ StdFunctionManager::StdFunctionManager(GeneratorVisitor *generator) { module = generator->module.get(); } -llvm::StructType *StdFunctionManager::getStringStructType() const { - llvm::Type *ptrTy = builder->getPtrTy(); - llvm::Type *int64Ty = builder->getInt64Ty(); - return llvm::StructType::create(*context, {ptrTy, int64Ty, int64Ty}, "_s__String__charptr_long_long"); +llvm::StructType *StdFunctionManager::getStringStructType(llvm::LLVMContext &context) { + std::string structTypeName = "_s__String__charptr_long_long"; + llvm::StructType *structType = llvm::StructType::getTypeByName(context, structTypeName); + if (structType != nullptr) + return structType; + llvm::Type *ptrTy = llvm::PointerType::get(context, 0); + llvm::Type *int64Ty = llvm::IntegerType::getInt64Ty(context); + return llvm::StructType::create(context, {ptrTy, int64Ty, int64Ty}, structTypeName); } llvm::Function *StdFunctionManager::getPrintfFct() const { @@ -31,7 +35,7 @@ llvm::Function *StdFunctionManager::getStackRestoreIntrinsic() const { } llvm::Function *StdFunctionManager::getStringGetRawFct() const { - return getFunction("_mf__String__getRaw", builder->getPtrTy(), getStringStructType()->getPointerTo()); + return getFunction("_mf__String__getRaw", builder->getPtrTy(), getStringStructType(*context)->getPointerTo()); } llvm::Function *StdFunctionManager::getStringCtorCharFct() const { @@ -46,6 +50,8 @@ llvm::Function *StdFunctionManager::getStringCtorStringStringFct() const { return getProcedure("_mp__String__ctor__string_string", {builder->getPtrTy(), builder->getPtrTy(), builder->getPtrTy()}); } +llvm::Function *StdFunctionManager::getStringDtorFct() const { return getProcedure("_mp__String__dtor", builder->getPtrTy()); } + llvm::Function *StdFunctionManager::getStringIsRawEqualStringStringFct() const { return getFunction("_mf__isRawEqual__string_string", builder->getInt1Ty(), {builder->getPtrTy(), builder->getPtrTy()}); } diff --git a/src/generator/StdFunctionManager.h b/src/generator/StdFunctionManager.h index 8eacd0cdd..4ffdc158c 100644 --- a/src/generator/StdFunctionManager.h +++ b/src/generator/StdFunctionManager.h @@ -14,7 +14,7 @@ class StdFunctionManager { explicit StdFunctionManager(GeneratorVisitor *generator); // Public methods for type retrieval - llvm::StructType *getStringStructType() const; + static llvm::StructType *getStringStructType(llvm::LLVMContext &context); // Public methods for function retrieval llvm::Function *getPrintfFct() const; @@ -25,6 +25,7 @@ class StdFunctionManager { llvm::Function *getStringCtorCharFct() const; llvm::Function *getStringCtorStringFct() const; llvm::Function *getStringCtorStringStringFct() const; + llvm::Function *getStringDtorFct() const; llvm::Function *getStringIsRawEqualStringStringFct() const; llvm::Function *getStringAppendStringFct() const; llvm::Function *getStringAppendCharFct() const; diff --git a/src/linker/LinkerInterface.cpp b/src/linker/LinkerInterface.cpp index c704e0f7c..b18bc4318 100644 --- a/src/linker/LinkerInterface.cpp +++ b/src/linker/LinkerInterface.cpp @@ -44,11 +44,15 @@ void LinkerInterface::link() { std::cout << "\nEmitting executable to path: " << outputPath << "\n"; // GCOV_EXCL_LINE // Call the linker - std::string result = FileUtil::exec(linkerCommand); + ExecResult result = FileUtil::exec(linkerCommand); + + // Check for linker error + if (result.exitCode != 0) + throw LinkerError(LINKER_ERROR, "Linker exited with non-zero exit code"); // Print linker result if appropriate - if (cliOptions.printDebugOutput && !result.empty()) - std::cout << "Linking result: " << result << "\n"; // GCOV_EXCL_LINE + if (cliOptions.printDebugOutput && !result.output.empty()) + std::cout << "Linking result: " << result.output << "\n"; // GCOV_EXCL_LINE } /** diff --git a/src/symbol/SymbolTable.cpp b/src/symbol/SymbolTable.cpp index cc719166f..0c9235423 100644 --- a/src/symbol/SymbolTable.cpp +++ b/src/symbol/SymbolTable.cpp @@ -30,6 +30,18 @@ void SymbolTable::insert(const std::string &name, const SymbolType &type, Symbol symbols.insert({name, SymbolTableEntry(name, type, this, specifiers, state, declNode, orderIndex, isGlobal)}); } +/** + * Insert a new anonymous symbol into the current symbol table. + * The anonymous symbol will be identified via the definition code location + * + * @param type Type of the symbol + * @param declNode AST node where the symbol is declared + */ +void SymbolTable::insertAnonymous(const SymbolType &type, const AstNode *declNode) { + std::string name = "anon." + declNode->codeLoc.toString(); + insert(name, type, SymbolSpecifiers(type), DECLARED, declNode); +} + /** * Add a capture to the capture list manually * @@ -122,6 +134,14 @@ SymbolTableEntry *SymbolTable::lookupGlobal(const std::string &globalName, bool return nullptr; } +/** + * Check if an anonymous symbol exists in the current scope and return it if possible + * + * @param codeLoc Definition code loc + * @return Anonymous symbol + */ +SymbolTableEntry *SymbolTable::lookupAnonymous(const CodeLoc &codeLoc) { return lookup("anon." + codeLoc.toString()); } + /** * Check if a capture exists in the current or any parent scope scope and return it if possible * @@ -274,20 +294,38 @@ SymbolTable *SymbolTable::getChild(const std::string &scopeId) { /** * Retrieve all variables that can be freed, because the ref count went down to 0. * + * @param Get only struct variables + * * @return Variables that can be de-allocated */ -std::vector SymbolTable::getVarsGoingOutOfScope(bool filterForStructs) { +std::vector SymbolTable::getVarsGoingOutOfScope(bool filterForDtorStructs) { assert(parent != nullptr); // Should not be called in root scope - // Collect all variables + // Collect all variables in this scope std::vector varsGoingOutOfScope; varsGoingOutOfScope.reserve(symbols.size()); for (auto [name, entry] : symbols) { if (name == THIS_VARIABLE_NAME) continue; - if (!filterForStructs || entry.getType().is(TY_STRUCT)) + if (!filterForDtorStructs) { + varsGoingOutOfScope.push_back(&symbols.at(name)); + continue; + } + // For dtor calls, only anonymous structs are relevant + if ((entry.getType().is(TY_STRUCT) || entry.getType().isStringStruct()) && entry.getName().starts_with("anon.")) varsGoingOutOfScope.push_back(&symbols.at(name)); } + + // Collect all variables in the child scopes + for (auto &[_, child] : children) { + ScopeType type = child->scopeType; + // Exclude enum, global, struct and thread body (is a LLVM function) scopes + if (type != SCOPE_ENUM && type != SCOPE_GLOBAL && type != SCOPE_STRUCT && type != SCOPE_THREAD_BODY) { + std::vector childVars = child->getVarsGoingOutOfScope(filterForDtorStructs); + varsGoingOutOfScope.insert(varsGoingOutOfScope.end(), childVars.begin(), childVars.end()); + } + } + return varsGoingOutOfScope; } @@ -828,4 +866,4 @@ nlohmann::json SymbolTable::toJSON() const { result["captures"] = jsonCaptures; result["children"] = jsonChildren; return result; -} \ No newline at end of file +} diff --git a/src/symbol/SymbolTable.h b/src/symbol/SymbolTable.h index 3c0591f6d..7f33772b1 100644 --- a/src/symbol/SymbolTable.h +++ b/src/symbol/SymbolTable.h @@ -47,11 +47,13 @@ class SymbolTable { // Public methods void insert(const std::string &name, const SymbolType &type, SymbolSpecifiers specifiers, SymbolState state, const AstNode *declNode); + void insertAnonymous(const SymbolType &type, const AstNode *declNode); void addCapture(const std::string &name, const Capture &capture); SymbolTableEntry *lookup(const std::string &symbolName); SymbolTableEntry *lookupStrict(const std::string &symbolName); SymbolTableEntry *lookupByIndex(unsigned int orderIndex); SymbolTableEntry *lookupGlobal(const std::string &globalName, bool skipThisScope = false); + SymbolTableEntry *lookupAnonymous(const CodeLoc &codeLoc); Capture *lookupCapture(const std::string &symbolName); Capture *lookupCaptureStrict(const std::string &symbolName); SymbolTable *lookupTable(const std::string &tableName); @@ -66,7 +68,7 @@ class SymbolTable { [[nodiscard]] SymbolTable *getParent() const; SymbolTable *getChild(const std::string &tableName); - std::vector getVarsGoingOutOfScope(bool filterForStructs = false); + std::vector getVarsGoingOutOfScope(bool filterForDtorStructs = false); std::map &getSymbols(); std::map &getCaptures(); diff --git a/src/symbol/SymbolType.cpp b/src/symbol/SymbolType.cpp index 06ed24db8..71102ff6f 100644 --- a/src/symbol/SymbolType.cpp +++ b/src/symbol/SymbolType.cpp @@ -6,6 +6,7 @@ #include #include +#include #include #include #include @@ -126,10 +127,7 @@ llvm::Type *SymbolType::toLLVMType(llvm::LLVMContext &context, SymbolTable *acce if (is(TY_STRING)) { if (typeChain.top().data.isStringStruct) { - std::string structName = "_s__String__charptr_long_long"; - llvm::Type *ptrTy = llvm::PointerType::get(context, 0); - llvm::Type *int64Ty = llvm::Type::getInt64Ty(context); - return llvm::StructType::create(context, {ptrTy, int64Ty, int64Ty}, structName); + return StdFunctionManager::getStringStructType(context); } else { return llvm::Type::getInt8PtrTy(context); } @@ -264,10 +262,7 @@ bool SymbolType::isOneOf(const std::vector &superTypes) const { * * @return String struct or not */ -bool SymbolType::isStringStruct() const { - SymbolSuperType superType = getSuperType(); - return superType == TY_STRING && typeChain.top().data.isStringStruct; -} +bool SymbolType::isStringStruct() const { return getSuperType() == TY_STRING && typeChain.top().data.isStringStruct; } /** * Retrieve the super type of the current type diff --git a/src/thirdparty/antlr-4.10.1-complete.jar b/src/thirdparty/antlr-4.10.1-complete.jar deleted file mode 100644 index c2f727a85..000000000 Binary files a/src/thirdparty/antlr-4.10.1-complete.jar and /dev/null differ diff --git a/src/thirdparty/antlr-4.11.1-complete.jar b/src/thirdparty/antlr-4.11.1-complete.jar new file mode 100644 index 000000000..bb96df951 Binary files /dev/null and b/src/thirdparty/antlr-4.11.1-complete.jar differ diff --git a/src/util/FileUtil.cpp b/src/util/FileUtil.cpp index 3006d743a..e4aa3d6a7 100644 --- a/src/util/FileUtil.cpp +++ b/src/util/FileUtil.cpp @@ -84,19 +84,20 @@ std::string FileUtil::getFileDir(const std::string &filePath) { return filePath. * Execute external command. Used to execute compiled binaries * * @param cmd Command to execute - * @return Output of the command as a string + * @return Result struct */ -std::string FileUtil::exec(const std::string &cmd) { - std::shared_ptr pipe(popen(cmd.c_str(), "r"), pclose); +ExecResult FileUtil::exec(const std::string &cmd) { + FILE *pipe = popen(cmd.c_str(), "r"); if (!pipe) throw std::runtime_error("Failed to execute command: " + cmd); char buffer[128]; std::string result; - while (!feof(pipe.get())) { - if (fgets(buffer, 128, pipe.get()) != nullptr) + while (!feof(pipe)) { + if (fgets(buffer, 128, pipe) != nullptr) result += buffer; } - return result; + int exitCode = pclose(pipe) / 256; + return { result, exitCode }; } /** diff --git a/src/util/FileUtil.h b/src/util/FileUtil.h index 61885dedf..cd55603cb 100644 --- a/src/util/FileUtil.h +++ b/src/util/FileUtil.h @@ -4,6 +4,11 @@ #include +struct ExecResult { + std::string output; + int exitCode; +}; + /** * Util class for file-related work */ @@ -22,7 +27,7 @@ class FileUtil { static void writeToFile(const std::string &fileName, const std::string &fileContent); static std::string getFileName(const std::string &filePath); static std::string getFileDir(const std::string &filePath); - static std::string exec(const std::string &cmd); + static ExecResult exec(const std::string &cmd); static bool isCommandAvailable(const std::string &cmd); static std::string getSpiceBinDir(); }; \ No newline at end of file diff --git a/std/runtime/string_rt.spice b/std/runtime/string_rt.spice index bdd095ef2..11a2fd8fb 100644 --- a/std/runtime/string_rt.spice +++ b/std/runtime/string_rt.spice @@ -15,9 +15,9 @@ ext memcpy(byte*, byte*, int); * String wrapper for enriching raw strings with information and make them mutable */ public type String struct { - char* contents // Pointer to the first char - unsigned long capacity // Allocated number of chars - unsigned long length // Current number of chars + char* contents // Pointer to the first char + unsigned long capacity // Allocated number of chars + unsigned long length // Current number of chars } public p String.ctor(const string value = "") { @@ -164,17 +164,6 @@ public inline p String.opMul(const short operand) { this.opMul((long) operand); } -/** - * Implements the equals operator for 'string == string' - * - * @param operand String to comare the current string to - * - * @return Equal or not - */ -public inline f String.opEquals(const String operand) { - return this.opEquals(operand.getRaw()); -} - /** * Implements the equals operator for 'string == string' * diff --git a/test/AnalyzerTest.cpp b/test/AnalyzerTest.cpp index 7a531d088..b0bbf2c09 100644 --- a/test/AnalyzerTest.cpp +++ b/test/AnalyzerTest.cpp @@ -181,10 +181,9 @@ void executeAnalyzerTest(const TestCase &testCase) { CommonUtil::replaceAll(errorWhat, "\\", "/"); std::string exceptionFile = testCase.testPath + FileUtil::DIR_SEPARATOR + "exception.out"; if (FileUtil::fileExists(exceptionFile)) { - if (TestUtil::isUpdateRefsEnabled()) { - // Update ref + if (TestUtil::isUpdateRefsEnabled()) { // Update ref FileUtil::writeToFile(exceptionFile, errorWhat); - } else { + } else { // Check ref std::string expectedException = TestUtil::getFileContent(exceptionFile); EXPECT_EQ(std::string(errorWhat), expectedException); } diff --git a/test/GeneratorTest.cpp b/test/GeneratorTest.cpp index 93585aecc..f0af1513d 100644 --- a/test/GeneratorTest.cpp +++ b/test/GeneratorTest.cpp @@ -247,16 +247,14 @@ void executeGeneratorTest(const TestCase &testCase) { linker.link(); // Execute the program and get the output - std::string actualOutput = FileUtil::exec(TestUtil::getDefaultExecutableName()); + ExecResult result = FileUtil::exec(TestUtil::getDefaultExecutableName()); + EXPECT_EQ(0, result.exitCode); - if (TestUtil::isUpdateRefsEnabled()) { - // Update ref - FileUtil::writeToFile(outputFileName, actualOutput); - } else { + if (TestUtil::isUpdateRefsEnabled()) { // Update ref + FileUtil::writeToFile(outputFileName, result.output); + } else { // Check ref std::string expectedOutput = TestUtil::getFileContent(outputFileName); - - // Check if the outputs are matching - EXPECT_EQ(expectedOutput, actualOutput); + EXPECT_EQ(expectedOutput, result.output); } } diff --git a/test/StdTest.cpp b/test/StdTest.cpp index a8091fe18..145c5b5e9 100644 --- a/test/StdTest.cpp +++ b/test/StdTest.cpp @@ -246,16 +246,14 @@ void executeStdTest(const TestCase &testCase) { linker.link(); // Execute the program and get the output - std::string actualOutput = FileUtil::exec(TestUtil::getDefaultExecutableName()); + ExecResult result = FileUtil::exec(TestUtil::getDefaultExecutableName()); + EXPECT_EQ(0, result.exitCode); - if (TestUtil::isUpdateRefsEnabled()) { - // Update ref - FileUtil::writeToFile(outputFileName, actualOutput); - } else { + if (TestUtil::isUpdateRefsEnabled()) { // Update ref + FileUtil::writeToFile(outputFileName, result.output); + } else { // Check ref std::string expectedOutput = TestUtil::getFileContent(outputFileName); - - // Check if the outputs are matching - EXPECT_EQ(expectedOutput, actualOutput); + EXPECT_EQ(expectedOutput, result.output); } } diff --git a/test/test-files/analyzer/coming-soon/error-coming-soon1/exception.out b/test/test-files/analyzer/coming-soon/error-coming-soon1/exception.out index 4e9ef16fc..e988cacab 100644 --- a/test/test-files/analyzer/coming-soon/error-coming-soon1/exception.out +++ b/test/test-files/analyzer/coming-soon/error-coming-soon1/exception.out @@ -1 +1 @@ -Semantic error in ./test-files/analyzer/coming-soon/error-coming-soon1/source.spice:1:1: Coming soon: Spice currently not supports pointer return types due to not supporting heap allocations. \ No newline at end of file +Semantic error in ./test-files/analyzer/coming-soon/error-coming-soon1/source.spice:1:1: Coming soon: Spice currently not supports pointer return types due to not handling pointer escaping. \ No newline at end of file diff --git a/test/test-files/generator/arbitrary/success-ackermann/ir-code-O3.ll b/test/test-files/generator/arbitrary/success-ackermann/ir-code-O3.ll index 207b1968f..2150545c0 100644 --- a/test/test-files/generator/arbitrary/success-ackermann/ir-code-O3.ll +++ b/test/test-files/generator/arbitrary/success-ackermann/ir-code-O3.ll @@ -12,25 +12,25 @@ entry.l1: br i1 %2, label %if.then.l2, label %if.end.l2 if.then.l2: ; preds = %tailrecurse.backedge, %entry.l1 - %.tr7.lcssa = phi i32 [ %1, %entry.l1 ], [ %.tr7.be, %tailrecurse.backedge ] - %3 = add i32 %.tr7.lcssa, 1 + %.tr15.lcssa = phi i32 [ %1, %entry.l1 ], [ %.tr15.be, %tailrecurse.backedge ] + %3 = add i32 %.tr15.lcssa, 1 ret i32 %3 if.end.l2: ; preds = %entry.l1, %tailrecurse.backedge - %.tr79 = phi i32 [ %.tr7.be, %tailrecurse.backedge ], [ %1, %entry.l1 ] - %.tr8 = phi i32 [ %.tr.be, %tailrecurse.backedge ], [ %0, %entry.l1 ] - %4 = icmp eq i32 %.tr79, 0 + %.tr1517 = phi i32 [ %.tr15.be, %tailrecurse.backedge ], [ %1, %entry.l1 ] + %.tr16 = phi i32 [ %.tr.be, %tailrecurse.backedge ], [ %0, %entry.l1 ] + %4 = icmp eq i32 %.tr1517, 0 br i1 %4, label %tailrecurse.backedge, label %if.end.l3 tailrecurse.backedge: ; preds = %if.end.l2, %if.end.l3 - %.tr7.be = phi i32 [ %7, %if.end.l3 ], [ 1, %if.end.l2 ] - %.tr.be = add i32 %.tr8, -1 + %.tr15.be = phi i32 [ %7, %if.end.l3 ], [ 1, %if.end.l2 ] + %.tr.be = add i32 %.tr16, -1 %5 = icmp eq i32 %.tr.be, 0 br i1 %5, label %if.then.l2, label %if.end.l2 if.end.l3: ; preds = %if.end.l2 - %6 = add i32 %.tr79, -1 - %7 = tail call fastcc i32 @_f__void__ack__int_int(i32 %.tr8, i32 %6) + %6 = add i32 %.tr1517, -1 + %7 = tail call fastcc i32 @_f__void__ack__int_int(i32 %.tr16, i32 %6) br label %tailrecurse.backedge } diff --git a/test/test-files/generator/arbitrary/success-ackermann/ir-code.ll b/test/test-files/generator/arbitrary/success-ackermann/ir-code.ll index 45e81a49f..8358cde0a 100644 --- a/test/test-files/generator/arbitrary/success-ackermann/ir-code.ll +++ b/test/test-files/generator/arbitrary/success-ackermann/ir-code.ll @@ -8,88 +8,88 @@ target triple = "x86_64-w64-windows-gnu" define internal i32 @_f__void__ack__int_int(i32 %0, i32 %1) { entry.l1: %m = alloca i32, align 4 - store i32 %0, ptr %m, align 4 %n = alloca i32, align 4 - store i32 %1, ptr %n, align 4 %result = alloca i32, align 4 - %2 = load i32, ptr %m, align 4 - %3 = icmp eq i32 %2, 0 + %2 = alloca i1, align 1 + %3 = alloca i32, align 4 %4 = alloca i1, align 1 - store i1 %3, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 - br i1 %5, label %if.then.l2, label %if.end.l2 + %5 = alloca i32, align 4 + %6 = alloca i32, align 4 + %7 = alloca i32, align 4 + %8 = alloca i32, align 4 + %9 = alloca i32, align 4 + %10 = alloca i32, align 4 + %11 = alloca i32, align 4 + store i32 %0, ptr %m, align 4 + store i32 %1, ptr %n, align 4 + %12 = load i32, ptr %m, align 4 + %13 = icmp eq i32 %12, 0 + store i1 %13, ptr %2, align 1 + %14 = load i1, ptr %2, align 1 + br i1 %14, label %if.then.l2, label %if.end.l2 if.then.l2: ; preds = %entry.l1 - %6 = load i32, ptr %n, align 4 - %7 = add i32 %6, 1 - %8 = alloca i32, align 4 - store i32 %7, ptr %8, align 4 - %9 = load i32, ptr %8, align 4 - ret i32 %9 + %15 = load i32, ptr %n, align 4 + %16 = add i32 %15, 1 + store i32 %16, ptr %3, align 4 + %17 = load i32, ptr %3, align 4 + ret i32 %17 if.end.l2: ; preds = %entry.l1 - %10 = load i32, ptr %n, align 4 - %11 = icmp eq i32 %10, 0 - %12 = alloca i1, align 1 - store i1 %11, ptr %12, align 1 - %13 = load i1, ptr %12, align 1 - br i1 %13, label %if.then.l3, label %if.end.l3 + %18 = load i32, ptr %n, align 4 + %19 = icmp eq i32 %18, 0 + store i1 %19, ptr %4, align 1 + %20 = load i1, ptr %4, align 1 + br i1 %20, label %if.then.l3, label %if.end.l3 if.then.l3: ; preds = %if.end.l2 - %14 = load i32, ptr %m, align 4 - %15 = sub i32 %14, 1 - %16 = alloca i32, align 4 - store i32 %15, ptr %16, align 4 - %17 = load i32, ptr %16, align 4 - %18 = alloca i32, align 4 - store i32 1, ptr %18, align 4 - %19 = load i32, ptr %18, align 4 - %20 = call i32 @_f__void__ack__int_int(i32 %17, i32 %19) - %21 = alloca i32, align 4 - store i32 %20, ptr %21, align 4 - %22 = load i32, ptr %21, align 4 - ret i32 %22 + %21 = load i32, ptr %m, align 4 + %22 = sub i32 %21, 1 + store i32 %22, ptr %5, align 4 + %23 = load i32, ptr %5, align 4 + store i32 1, ptr %6, align 4 + %24 = load i32, ptr %6, align 4 + %25 = call i32 @_f__void__ack__int_int(i32 %23, i32 %24) + store i32 %25, ptr %7, align 4 + %26 = load i32, ptr %7, align 4 + ret i32 %26 if.end.l3: ; preds = %if.end.l2 - %23 = load i32, ptr %m, align 4 - %24 = sub i32 %23, 1 - %25 = alloca i32, align 4 - store i32 %24, ptr %25, align 4 - %26 = load i32, ptr %25, align 4 %27 = load i32, ptr %m, align 4 - %28 = load i32, ptr %n, align 4 - %29 = sub i32 %28, 1 - %30 = alloca i32, align 4 - store i32 %29, ptr %30, align 4 - %31 = load i32, ptr %30, align 4 - %32 = call i32 @_f__void__ack__int_int(i32 %27, i32 %31) - %33 = alloca i32, align 4 - store i32 %32, ptr %33, align 4 - %34 = load i32, ptr %33, align 4 - %35 = call i32 @_f__void__ack__int_int(i32 %26, i32 %34) - %36 = alloca i32, align 4 - store i32 %35, ptr %36, align 4 - %37 = load i32, ptr %36, align 4 + %28 = sub i32 %27, 1 + store i32 %28, ptr %8, align 4 + %29 = load i32, ptr %8, align 4 + %30 = load i32, ptr %m, align 4 + %31 = load i32, ptr %n, align 4 + %32 = sub i32 %31, 1 + store i32 %32, ptr %9, align 4 + %33 = load i32, ptr %9, align 4 + %34 = call i32 @_f__void__ack__int_int(i32 %30, i32 %33) + store i32 %34, ptr %10, align 4 + %35 = load i32, ptr %10, align 4 + %36 = call i32 @_f__void__ack__int_int(i32 %29, i32 %35) + store i32 %36, ptr %11, align 4 + %37 = load i32, ptr %11, align 4 ret i32 %37 } define i32 @main() { entry.l7: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %baseM = alloca i32, align 4 - store i32 3, ptr %baseM, align 4 %baseN = alloca i32, align 4 + %0 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 3, ptr %baseM, align 4 store i32 12, ptr %baseN, align 4 - %0 = load i32, ptr %baseM, align 4 - %1 = load i32, ptr %baseN, align 4 - %2 = load i32, ptr %baseM, align 4 - %3 = load i32, ptr %baseN, align 4 - %4 = call i32 @_f__void__ack__int_int(i32 %2, i32 %3) - %5 = alloca i32, align 4 - store i32 %4, ptr %5, align 4 - %6 = load i32, ptr %5, align 4 - %7 = call i32 (ptr, ...) @printf(ptr @0, i32 %0, i32 %1, i32 %6) + %1 = load i32, ptr %baseM, align 4 + %2 = load i32, ptr %baseN, align 4 + %3 = load i32, ptr %baseM, align 4 + %4 = load i32, ptr %baseN, align 4 + %5 = call i32 @_f__void__ack__int_int(i32 %3, i32 %4) + store i32 %5, ptr %0, align 4 + %6 = load i32, ptr %0, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @0, i32 %1, i32 %2, i32 %6) %8 = load i32, ptr %result, align 4 ret i32 %8 } diff --git a/test/test-files/generator/arbitrary/success-faculty/ir-code.ll b/test/test-files/generator/arbitrary/success-faculty/ir-code.ll index bdc9d9cef..2e24fcabe 100644 --- a/test/test-files/generator/arbitrary/success-faculty/ir-code.ll +++ b/test/test-files/generator/arbitrary/success-faculty/ir-code.ll @@ -8,53 +8,61 @@ target triple = "x86_64-w64-windows-gnu" define internal i32 @_f__void__faculty__int(i32 %0) { entry.l1: %input = alloca i32, align 4 - store i32 %0, ptr %input, align 4 %result = alloca i32, align 4 - %1 = load i32, ptr %input, align 4 - %2 = icmp slt i32 %1, 2 - %3 = alloca i1, align 1 - store i1 %2, ptr %3, align 1 - %4 = load i1, ptr %3, align 1 - br i1 %4, label %if.then.l2, label %if.end.l2 + %1 = alloca i1, align 1 + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 + %6 = alloca i32, align 4 + %7 = alloca i32, align 4 + store i32 %0, ptr %input, align 4 + %8 = load i32, ptr %input, align 4 + %9 = icmp slt i32 %8, 2 + store i1 %9, ptr %1, align 1 + %10 = load i1, ptr %1, align 1 + br i1 %10, label %if.then.l2, label %if.end.l2 if.then.l2: ; preds = %entry.l1 - %5 = alloca i32, align 4 - store i32 1, ptr %5, align 4 - %6 = load i32, ptr %5, align 4 - ret i32 %6 + store i32 1, ptr %2, align 4 + %11 = load i32, ptr %2, align 4 + ret i32 %11 if.end.l2: ; preds = %entry.l1 - %7 = load i32, ptr %input, align 4 - %8 = load i32, ptr %input, align 4 - %9 = sub i32 %8, 1 - %10 = alloca i32, align 4 - store i32 %9, ptr %10, align 4 - %11 = load i32, ptr %10, align 4 - %12 = call i32 @_f__void__faculty__int(i32 %11) - %13 = alloca i32, align 4 - store i32 %12, ptr %13, align 4 - %14 = load i32, ptr %13, align 4 - %15 = mul i32 %7, %14 - %16 = alloca i32, align 4 - store i32 %15, ptr %16, align 4 - %17 = load i32, ptr %16, align 4 - store i32 %17, ptr %result, align 4 - %18 = load i32, ptr %result, align 4 - ret i32 %18 + %12 = load i32, ptr %input, align 4 + %13 = load i32, ptr %input, align 4 + %14 = sub i32 %13, 1 + store i32 %14, ptr %3, align 4 + %15 = load i32, ptr %3, align 4 + %16 = call i32 @_f__void__faculty__int(i32 %15) + store i32 %16, ptr %4, align 4 + %17 = load i32, ptr %4, align 4 + %18 = load i32, ptr %input, align 4 + %19 = sub i32 %18, 1 + store i32 %19, ptr %5, align 4 + %20 = load i32, ptr %5, align 4 + %21 = call i32 @_f__void__faculty__int(i32 %20) + store i32 %21, ptr %6, align 4 + %22 = mul i32 %12, %17 + store i32 %22, ptr %7, align 4 + %23 = load i32, ptr %7, align 4 + store i32 %23, ptr %result, align 4 + %24 = load i32, ptr %result, align 4 + ret i32 %24 } define i32 @main() { entry.l8: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %input = alloca i32, align 4 + %0 = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i32 10, ptr %input, align 4 - %0 = load i32, ptr %input, align 4 - %1 = call i32 @_f__void__faculty__int(i32 %0) - %2 = alloca i32, align 4 - store i32 %1, ptr %2, align 4 + %1 = load i32, ptr %input, align 4 + %2 = call i32 @_f__void__faculty__int(i32 %1) + store i32 %2, ptr %0, align 4 %3 = load i32, ptr %input, align 4 - %4 = load i32, ptr %2, align 4 + %4 = load i32, ptr %0, align 4 %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %3, i32 %4) %6 = load i32, ptr %result, align 4 ret i32 %6 diff --git a/test/test-files/generator/arbitrary/success-fibonacci-threaded/ir-code-O3.ll b/test/test-files/generator/arbitrary/success-fibonacci-threaded/ir-code-O3.ll index 835e4ec57..3876486f3 100644 --- a/test/test-files/generator/arbitrary/success-fibonacci-threaded/ir-code-O3.ll +++ b/test/test-files/generator/arbitrary/success-fibonacci-threaded/ir-code-O3.ll @@ -22,13 +22,13 @@ common.ret: ; preds = %common.ret.loopexit ret i32 %accumulator.tr.lcssa if.end.l2: ; preds = %entry.l1, %if.end.l2 - %.tr4 = phi i32 [ %4, %if.end.l2 ], [ %0, %entry.l1 ] - %accumulator.tr3 = phi i32 [ %5, %if.end.l2 ], [ 0, %entry.l1 ] - %2 = add nsw i32 %.tr4, -1 + %.tr9 = phi i32 [ %4, %if.end.l2 ], [ %0, %entry.l1 ] + %accumulator.tr8 = phi i32 [ %5, %if.end.l2 ], [ 0, %entry.l1 ] + %2 = add nsw i32 %.tr9, -1 %3 = tail call fastcc i32 @_f__void__fib__int(i32 %2) - %4 = add nsw i32 %.tr4, -2 - %5 = add i32 %3, %accumulator.tr3 - %6 = icmp ult i32 %.tr4, 5 + %4 = add nsw i32 %.tr9, -2 + %5 = add i32 %3, %accumulator.tr8 + %6 = icmp ult i32 %.tr9, 5 br i1 %6, label %common.ret.loopexit, label %if.end.l2 } diff --git a/test/test-files/generator/arbitrary/success-fibonacci/ir-code-O3.ll b/test/test-files/generator/arbitrary/success-fibonacci/ir-code-O3.ll index d4439c608..51a14b479 100644 --- a/test/test-files/generator/arbitrary/success-fibonacci/ir-code-O3.ll +++ b/test/test-files/generator/arbitrary/success-fibonacci/ir-code-O3.ll @@ -20,13 +20,13 @@ common.ret: ; preds = %common.ret.loopexit ret i32 %accumulator.tr.lcssa if.end.l2: ; preds = %entry.l1, %if.end.l2 - %.tr4 = phi i32 [ %4, %if.end.l2 ], [ %0, %entry.l1 ] - %accumulator.tr3 = phi i32 [ %5, %if.end.l2 ], [ 0, %entry.l1 ] - %2 = add nsw i32 %.tr4, -1 + %.tr9 = phi i32 [ %4, %if.end.l2 ], [ %0, %entry.l1 ] + %accumulator.tr8 = phi i32 [ %5, %if.end.l2 ], [ 0, %entry.l1 ] + %2 = add nsw i32 %.tr9, -1 %3 = tail call fastcc i32 @_f__void__fib__int(i32 %2) - %4 = add nsw i32 %.tr4, -2 - %5 = add i32 %3, %accumulator.tr3 - %6 = icmp ult i32 %.tr4, 5 + %4 = add nsw i32 %.tr9, -2 + %5 = add i32 %3, %accumulator.tr8 + %6 = icmp ult i32 %.tr9, 5 br i1 %6, label %common.ret.loopexit, label %if.end.l2 } diff --git a/test/test-files/generator/arbitrary/success-fibonacci/ir-code.ll b/test/test-files/generator/arbitrary/success-fibonacci/ir-code.ll index d49f974b6..ab35101f1 100644 --- a/test/test-files/generator/arbitrary/success-fibonacci/ir-code.ll +++ b/test/test-files/generator/arbitrary/success-fibonacci/ir-code.ll @@ -8,60 +8,60 @@ target triple = "x86_64-w64-windows-gnu" define internal i32 @_f__void__fib__int(i32 %0) { entry.l1: %n = alloca i32, align 4 - store i32 %0, ptr %n, align 4 %result = alloca i32, align 4 - %1 = load i32, ptr %n, align 4 - %2 = icmp sle i32 %1, 2 - %3 = alloca i1, align 1 - store i1 %2, ptr %3, align 1 - %4 = load i1, ptr %3, align 1 - br i1 %4, label %if.then.l2, label %if.end.l2 + %1 = alloca i1, align 1 + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 + %6 = alloca i32, align 4 + %7 = alloca i32, align 4 + store i32 %0, ptr %n, align 4 + %8 = load i32, ptr %n, align 4 + %9 = icmp sle i32 %8, 2 + store i1 %9, ptr %1, align 1 + %10 = load i1, ptr %1, align 1 + br i1 %10, label %if.then.l2, label %if.end.l2 if.then.l2: ; preds = %entry.l1 - %5 = alloca i32, align 4 - store i32 1, ptr %5, align 4 - %6 = load i32, ptr %5, align 4 - ret i32 %6 + store i32 1, ptr %2, align 4 + %11 = load i32, ptr %2, align 4 + ret i32 %11 if.end.l2: ; preds = %entry.l1 - %7 = load i32, ptr %n, align 4 - %8 = sub i32 %7, 1 - %9 = alloca i32, align 4 - store i32 %8, ptr %9, align 4 - %10 = load i32, ptr %9, align 4 - %11 = call i32 @_f__void__fib__int(i32 %10) - %12 = alloca i32, align 4 - store i32 %11, ptr %12, align 4 - %13 = load i32, ptr %12, align 4 - %14 = load i32, ptr %n, align 4 - %15 = sub i32 %14, 2 - %16 = alloca i32, align 4 - store i32 %15, ptr %16, align 4 - %17 = load i32, ptr %16, align 4 - %18 = call i32 @_f__void__fib__int(i32 %17) - %19 = alloca i32, align 4 - store i32 %18, ptr %19, align 4 - %20 = load i32, ptr %19, align 4 - %21 = add i32 %13, %20 - %22 = alloca i32, align 4 - store i32 %21, ptr %22, align 4 - %23 = load i32, ptr %22, align 4 + %12 = load i32, ptr %n, align 4 + %13 = sub i32 %12, 1 + store i32 %13, ptr %3, align 4 + %14 = load i32, ptr %3, align 4 + %15 = call i32 @_f__void__fib__int(i32 %14) + store i32 %15, ptr %4, align 4 + %16 = load i32, ptr %4, align 4 + %17 = load i32, ptr %n, align 4 + %18 = sub i32 %17, 2 + store i32 %18, ptr %5, align 4 + %19 = load i32, ptr %5, align 4 + %20 = call i32 @_f__void__fib__int(i32 %19) + store i32 %20, ptr %6, align 4 + %21 = load i32, ptr %6, align 4 + %22 = add i32 %16, %21 + store i32 %22, ptr %7, align 4 + %23 = load i32, ptr %7, align 4 ret i32 %23 } define i32 @main() { entry.l6: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %base = alloca i32, align 4 + %0 = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i32 46, ptr %base, align 4 - %0 = load i32, ptr %base, align 4 %1 = load i32, ptr %base, align 4 - %2 = call i32 @_f__void__fib__int(i32 %1) - %3 = alloca i32, align 4 - store i32 %2, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 - %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %0, i32 %4) + %2 = load i32, ptr %base, align 4 + %3 = call i32 @_f__void__fib__int(i32 %2) + store i32 %3, ptr %0, align 4 + %4 = load i32, ptr %0, align 4 + %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %1, i32 %4) %6 = load i32, ptr %result, align 4 ret i32 %6 } diff --git a/test/test-files/generator/arbitrary/success-pidigits/ir-code-O3.ll b/test/test-files/generator/arbitrary/success-pidigits/ir-code-O3.ll index 3940ec52c..5869e0d3e 100644 --- a/test/test-files/generator/arbitrary/success-pidigits/ir-code-O3.ll +++ b/test/test-files/generator/arbitrary/success-pidigits/ir-code-O3.ll @@ -11,24 +11,24 @@ entry.l4: br label %for.l21 for.l21: ; preds = %entry.l4, %for.inc.l21 - %i.035 = phi i32 [ 0, %entry.l4 ], [ %29, %for.inc.l21 ] - %printedDigits.134 = phi i32 [ 0, %entry.l4 ], [ %printedDigits.0, %for.inc.l21 ] - %q.133 = phi i64 [ 1, %entry.l4 ], [ %q.0, %for.inc.l21 ] - %x.132 = phi i64 [ 3, %entry.l4 ], [ %x.0, %for.inc.l21 ] - %r.131 = phi i64 [ 0, %entry.l4 ], [ %r.0, %for.inc.l21 ] - %m.130 = phi i64 [ 3, %entry.l4 ], [ %m.0, %for.inc.l21 ] - %k.129 = phi i64 [ 1, %entry.l4 ], [ %k.0, %for.inc.l21 ] - %t.128 = phi i64 [ 1, %entry.l4 ], [ %t.0, %for.inc.l21 ] - %0 = shl i64 %q.133, 2 - %1 = sub i64 %r.131, %t.128 + %q.185 = phi i64 [ 1, %entry.l4 ], [ %q.0, %for.inc.l21 ] + %r.184 = phi i64 [ 0, %entry.l4 ], [ %r.0, %for.inc.l21 ] + %t.183 = phi i64 [ 1, %entry.l4 ], [ %t.0, %for.inc.l21 ] + %k.182 = phi i64 [ 1, %entry.l4 ], [ %k.0, %for.inc.l21 ] + %m.181 = phi i64 [ 3, %entry.l4 ], [ %m.0, %for.inc.l21 ] + %x.180 = phi i64 [ 3, %entry.l4 ], [ %x.0, %for.inc.l21 ] + %printedDigits.179 = phi i32 [ 0, %entry.l4 ], [ %printedDigits.0, %for.inc.l21 ] + %i.078 = phi i32 [ 0, %entry.l4 ], [ %29, %for.inc.l21 ] + %0 = shl i64 %q.185, 2 + %1 = sub i64 %r.184, %t.183 %2 = add i64 %1, %0 - %3 = mul i64 %m.130, %t.128 + %3 = mul i64 %t.183, %m.181 %4 = icmp slt i64 %2, %3 br i1 %4, label %if.then.l22, label %if.else.l22 if.then.l22: ; preds = %for.l21 - %5 = tail call i32 (ptr, ...) @printf(ptr nonnull @0, i64 %m.130) - %6 = icmp eq i32 %printedDigits.134, 0 + %5 = tail call i32 (ptr, ...) @printf(ptr nonnull @0, i64 %m.181) + %6 = icmp eq i32 %printedDigits.179, 0 br i1 %6, label %if.then.l24, label %if.end.l24 if.then.l24: ; preds = %if.then.l22 @@ -36,43 +36,43 @@ if.then.l24: ; preds = %if.then.l22 br label %if.end.l24 if.end.l24: ; preds = %if.then.l24, %if.then.l22 - %7 = add i32 %printedDigits.134, 1 - %8 = mul i64 %q.133, 10 - %9 = sub i64 %r.131, %3 + %7 = add i32 %printedDigits.179, 1 + %8 = mul i64 %q.185, 10 + %9 = sub i64 %r.184, %3 %10 = mul i64 %9, 10 - %11 = mul i64 %q.133, 3 - %12 = add i64 %11, %r.131 + %11 = mul i64 %q.185, 3 + %12 = add i64 %11, %r.184 %13 = mul i64 %12, 10 - %14 = sdiv i64 %13, %t.128 - %.neg = mul i64 %m.130, -10 + %14 = sdiv i64 %13, %t.183 + %.neg = mul i64 %m.181, -10 %15 = add i64 %14, %.neg br label %for.inc.l21 if.else.l22: ; preds = %for.l21 - %16 = mul i64 %q.133, %k.129 - %17 = shl i64 %q.133, 1 - %18 = add i64 %17, %r.131 - %19 = mul i64 %18, %x.132 - %20 = mul i64 %x.132, %t.128 - %21 = add i64 %k.129, 1 - %22 = mul i64 %k.129, 7 + %16 = mul i64 %q.185, %k.182 + %17 = shl i64 %q.185, 1 + %18 = add i64 %17, %r.184 + %19 = mul i64 %18, %x.180 + %20 = mul i64 %t.183, %x.180 + %21 = add i64 %k.182, 1 + %22 = mul i64 %k.182, 7 %23 = add i64 %22, 2 - %24 = mul i64 %q.133, %23 - %25 = mul i64 %x.132, %r.131 + %24 = mul i64 %q.185, %23 + %25 = mul i64 %r.184, %x.180 %26 = add i64 %24, %25 %27 = sdiv i64 %26, %20 - %28 = add i64 %x.132, 2 + %28 = add i64 %x.180, 2 br label %for.inc.l21 for.inc.l21: ; preds = %if.end.l24, %if.else.l22 - %t.0 = phi i64 [ %t.128, %if.end.l24 ], [ %20, %if.else.l22 ] - %k.0 = phi i64 [ %k.129, %if.end.l24 ], [ %21, %if.else.l22 ] + %printedDigits.0 = phi i32 [ %7, %if.end.l24 ], [ %printedDigits.179, %if.else.l22 ] + %x.0 = phi i64 [ %x.180, %if.end.l24 ], [ %28, %if.else.l22 ] %m.0 = phi i64 [ %15, %if.end.l24 ], [ %27, %if.else.l22 ] + %k.0 = phi i64 [ %k.182, %if.end.l24 ], [ %21, %if.else.l22 ] + %t.0 = phi i64 [ %t.183, %if.end.l24 ], [ %20, %if.else.l22 ] %r.0 = phi i64 [ %10, %if.end.l24 ], [ %19, %if.else.l22 ] - %x.0 = phi i64 [ %x.132, %if.end.l24 ], [ %28, %if.else.l22 ] %q.0 = phi i64 [ %8, %if.end.l24 ], [ %16, %if.else.l22 ] - %printedDigits.0 = phi i32 [ %7, %if.end.l24 ], [ %printedDigits.134, %if.else.l22 ] - %29 = add nuw nsw i32 %i.035, 1 + %29 = add nuw nsw i32 %i.078, 1 %exitcond.not = icmp eq i32 %29, 20 br i1 %exitcond.not, label %for.end.l21, label %for.l21 diff --git a/test/test-files/generator/arbitrary/success-pidigits/ir-code.ll b/test/test-files/generator/arbitrary/success-pidigits/ir-code.ll index b70dbe3b3..631618d66 100644 --- a/test/test-files/generator/arbitrary/success-pidigits/ir-code.ll +++ b/test/test-files/generator/arbitrary/success-pidigits/ir-code.ll @@ -9,249 +9,307 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l4: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %q = alloca i64, align 8 - store i64 1, ptr %q, align 8 %q_new = alloca i64, align 8 - store i64 0, ptr %q_new, align 8 %r = alloca i64, align 8 - store i64 0, ptr %r, align 8 %r_new = alloca i64, align 8 - store i64 0, ptr %r_new, align 8 %t = alloca i64, align 8 - store i64 1, ptr %t, align 8 %t_new = alloca i64, align 8 - store i64 0, ptr %t_new, align 8 %k = alloca i64, align 8 - store i64 1, ptr %k, align 8 %k_new = alloca i64, align 8 - store i64 0, ptr %k_new, align 8 %m = alloca i64, align 8 - store i64 3, ptr %m, align 8 %m_new = alloca i64, align 8 - store i64 0, ptr %m_new, align 8 %x = alloca i64, align 8 - store i64 3, ptr %x, align 8 %x_new = alloca i64, align 8 - store i64 0, ptr %x_new, align 8 %iterations = alloca i32, align 4 - store i32 20, ptr %iterations, align 4 %printedDigits = alloca i32, align 4 - store i32 0, ptr %printedDigits, align 4 %i = alloca i32, align 4 + %i1 = alloca i64, align 8 + %0 = alloca i64, align 8 + %1 = alloca i64, align 8 + %2 = alloca i64, align 8 + %3 = alloca i1, align 1 + %4 = alloca i1, align 1 + %5 = alloca i32, align 4 + %q_new2 = alloca i64, align 8 + %6 = alloca i64, align 8 + %7 = alloca i64, align 8 + %8 = alloca i64, align 8 + %r_new3 = alloca i64, align 8 + %9 = alloca i64, align 8 + %10 = alloca i64, align 8 + %11 = alloca i64, align 8 + %m4 = alloca i64, align 8 + %12 = alloca i64, align 8 + %13 = alloca i64, align 8 + %m5 = alloca i64, align 8 + %m6 = alloca i64, align 8 + %14 = alloca i64, align 8 + %15 = alloca i64, align 8 + %16 = alloca i64, align 8 + %17 = alloca i64, align 8 + %m7 = alloca i64, align 8 + %18 = alloca i64, align 8 + %19 = alloca i64, align 8 + %20 = alloca i64, align 8 + %r_new8 = alloca i64, align 8 + %21 = alloca i64, align 8 + %22 = alloca i64, align 8 + %r_new9 = alloca i64, align 8 + %23 = alloca i64, align 8 + %24 = alloca i64, align 8 + %25 = alloca i64, align 8 + %26 = alloca i64, align 8 + %27 = alloca i64, align 8 + %m10 = alloca i64, align 8 + %28 = alloca i64, align 8 + %29 = alloca i64, align 8 + %m11 = alloca i64, align 8 + %30 = alloca i64, align 8 + %31 = alloca i64, align 8 + %32 = alloca i64, align 8 + %33 = alloca i64, align 8 + %34 = alloca i64, align 8 + %35 = alloca i64, align 8 + %36 = alloca i64, align 8 + %37 = alloca i32, align 4 + %38 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + store i64 1, ptr %q, align 8 + store i64 0, ptr %q_new, align 8 + store i64 0, ptr %r, align 8 + store i64 0, ptr %r_new, align 8 + store i64 1, ptr %t, align 8 + store i64 0, ptr %t_new, align 8 + store i64 1, ptr %k, align 8 + store i64 0, ptr %k_new, align 8 + store i64 3, ptr %m, align 8 + store i64 0, ptr %m_new, align 8 + store i64 3, ptr %x, align 8 + store i64 0, ptr %x_new, align 8 + store i32 20, ptr %iterations, align 4 + store i32 0, ptr %printedDigits, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l21 for.l21: ; preds = %for.cond.l21 - %0 = load i64, ptr %q, align 8 - %1 = mul i64 4, %0 - %2 = alloca i64, align 8 - store i64 %1, ptr %2, align 8 - %3 = load i64, ptr %2, align 8 - %4 = load i64, ptr %r, align 8 - %5 = add i64 %3, %4 - %6 = load i64, ptr %t, align 8 - %7 = sub i64 %5, %6 - %8 = alloca i64, align 8 - store i64 %7, ptr %8, align 8 - %9 = load i64, ptr %8, align 8 - %10 = load i64, ptr %m, align 8 - %11 = load i64, ptr %t, align 8 - %12 = mul i64 %10, %11 - %13 = alloca i64, align 8 - store i64 %12, ptr %13, align 8 - %14 = load i64, ptr %13, align 8 - %15 = icmp slt i64 %9, %14 - %16 = alloca i1, align 1 - store i1 %15, ptr %16, align 1 - %17 = load i1, ptr %16, align 1 - br i1 %17, label %if.then.l22, label %if.else.l22 + %39 = load i64, ptr %q, align 8 + store i64 4, ptr %i1, align 8 + %40 = mul i64 4, %39 + store i64 %40, ptr %0, align 8 + %41 = load i64, ptr %0, align 8 + %42 = load i64, ptr %r, align 8 + %43 = add i64 %41, %42 + %44 = load i64, ptr %t, align 8 + %45 = sub i64 %43, %44 + store i64 %45, ptr %1, align 8 + %46 = load i64, ptr %1, align 8 + %47 = load i64, ptr %m, align 8 + %48 = load i64, ptr %t, align 8 + %49 = mul i64 %47, %48 + store i64 %49, ptr %2, align 8 + %50 = load i64, ptr %2, align 8 + %51 = icmp slt i64 %46, %50 + store i1 %51, ptr %3, align 1 + %52 = load i1, ptr %3, align 1 + br i1 %52, label %if.then.l22, label %if.else.l22 if.then.l22: ; preds = %for.l21 - %18 = load i64, ptr %m, align 8 - %19 = call i32 (ptr, ...) @printf(ptr @0, i64 %18) - %20 = load i32, ptr %printedDigits, align 4 - %21 = icmp eq i32 %20, 0 - %22 = alloca i1, align 1 - store i1 %21, ptr %22, align 1 - %23 = load i1, ptr %22, align 1 - br i1 %23, label %if.then.l24, label %if.end.l24 + %53 = load i64, ptr %m, align 8 + %54 = call i32 (ptr, ...) @printf(ptr @0, i64 %53) + %55 = load i32, ptr %printedDigits, align 4 + %56 = icmp eq i32 %55, 0 + store i1 %56, ptr %4, align 1 + %57 = load i1, ptr %4, align 1 + br i1 %57, label %if.then.l24, label %if.end.l24 if.then.l24: ; preds = %if.then.l22 - %24 = call i32 (ptr, ...) @printf(ptr @1) + %58 = call i32 (ptr, ...) @printf(ptr @1) br label %if.end.l24 if.end.l24: ; preds = %if.then.l24, %if.then.l22 - %25 = load i32, ptr %printedDigits, align 4 - %26 = add i32 %25, 1 - store i32 %26, ptr %printedDigits, align 4 - %27 = alloca i32, align 4 - store i32 %25, ptr %27, align 4 - %28 = load i64, ptr %q, align 8 - %29 = mul i64 10, %28 - %30 = alloca i64, align 8 - store i64 %29, ptr %30, align 8 - %31 = load i64, ptr %30, align 8 - store i64 %31, ptr %q_new, align 8 - %32 = load i64, ptr %r, align 8 - %33 = load i64, ptr %m, align 8 - %34 = load i64, ptr %t, align 8 - %35 = mul i64 %33, %34 - %36 = alloca i64, align 8 - store i64 %35, ptr %36, align 8 - %37 = load i64, ptr %36, align 8 - %38 = sub i64 %32, %37 - %39 = alloca i64, align 8 - store i64 %38, ptr %39, align 8 - %40 = load i64, ptr %39, align 8 - %41 = mul i64 10, %40 - %42 = alloca i64, align 8 - store i64 %41, ptr %42, align 8 - %43 = load i64, ptr %42, align 8 - store i64 %43, ptr %r_new, align 8 - %44 = load i64, ptr %q, align 8 - %45 = mul i64 3, %44 - %46 = alloca i64, align 8 - store i64 %45, ptr %46, align 8 - %47 = load i64, ptr %46, align 8 - %48 = load i64, ptr %r, align 8 - %49 = add i64 %47, %48 - %50 = alloca i64, align 8 - store i64 %49, ptr %50, align 8 - %51 = load i64, ptr %50, align 8 - %52 = mul i64 10, %51 - %53 = alloca i64, align 8 - store i64 %52, ptr %53, align 8 - %54 = load i64, ptr %53, align 8 - %55 = load i64, ptr %t, align 8 - %56 = sdiv i64 %54, %55 - %57 = alloca i64, align 8 - store i64 %56, ptr %57, align 8 - %58 = load i64, ptr %57, align 8 - %59 = load i64, ptr %m, align 8 - %60 = mul i64 10, %59 - %61 = alloca i64, align 8 - store i64 %60, ptr %61, align 8 - %62 = load i64, ptr %61, align 8 - %63 = sub i64 %58, %62 - %64 = alloca i64, align 8 - store i64 %63, ptr %64, align 8 - %65 = load i64, ptr %64, align 8 - store i64 %65, ptr %m, align 8 - %66 = load i64, ptr %q_new, align 8 - store i64 %66, ptr %q, align 8 - %67 = load i64, ptr %r_new, align 8 - store i64 %67, ptr %r, align 8 + %59 = load i32, ptr %printedDigits, align 4 + %60 = add i32 %59, 1 + store i32 %60, ptr %printedDigits, align 4 + store i32 %59, ptr %5, align 4 + %61 = load i64, ptr %q, align 8 + store i64 10, ptr %q_new2, align 8 + %62 = mul i64 10, %61 + store i64 %62, ptr %6, align 8 + %63 = load i64, ptr %6, align 8 + store i64 %63, ptr %q_new, align 8 + %64 = load i64, ptr %r, align 8 + %65 = load i64, ptr %m, align 8 + %66 = load i64, ptr %t, align 8 + %67 = mul i64 %65, %66 + store i64 %67, ptr %7, align 8 + %68 = load i64, ptr %7, align 8 + %69 = sub i64 %64, %68 + store i64 %69, ptr %8, align 8 + %70 = load i64, ptr %8, align 8 + store i64 10, ptr %r_new3, align 8 + %71 = load i64, ptr %r, align 8 + %72 = load i64, ptr %m, align 8 + %73 = load i64, ptr %t, align 8 + %74 = mul i64 %72, %73 + store i64 %74, ptr %9, align 8 + %75 = load i64, ptr %9, align 8 + %76 = sub i64 %71, %75 + store i64 %76, ptr %10, align 8 + %77 = mul i64 10, %70 + store i64 %77, ptr %11, align 8 + %78 = load i64, ptr %11, align 8 + store i64 %78, ptr %r_new, align 8 + %79 = load i64, ptr %q, align 8 + store i64 3, ptr %m4, align 8 + %80 = mul i64 3, %79 + store i64 %80, ptr %12, align 8 + %81 = load i64, ptr %12, align 8 + %82 = load i64, ptr %r, align 8 + %83 = add i64 %81, %82 + store i64 %83, ptr %13, align 8 + %84 = load i64, ptr %13, align 8 + store i64 10, ptr %m5, align 8 + %85 = load i64, ptr %q, align 8 + store i64 3, ptr %m6, align 8 + %86 = mul i64 3, %85 + store i64 %86, ptr %14, align 8 + %87 = load i64, ptr %14, align 8 + %88 = load i64, ptr %r, align 8 + %89 = add i64 %87, %88 + store i64 %89, ptr %15, align 8 + %90 = mul i64 10, %84 + store i64 %90, ptr %16, align 8 + %91 = load i64, ptr %16, align 8 + %92 = load i64, ptr %t, align 8 + %93 = sdiv i64 %91, %92 + store i64 %93, ptr %17, align 8 + %94 = load i64, ptr %17, align 8 + %95 = load i64, ptr %m, align 8 + store i64 10, ptr %m7, align 8 + %96 = mul i64 10, %95 + store i64 %96, ptr %18, align 8 + %97 = load i64, ptr %18, align 8 + %98 = sub i64 %94, %97 + store i64 %98, ptr %19, align 8 + %99 = load i64, ptr %19, align 8 + store i64 %99, ptr %m, align 8 + %100 = load i64, ptr %q_new, align 8 + store i64 %100, ptr %q, align 8 + %101 = load i64, ptr %r_new, align 8 + store i64 %101, ptr %r, align 8 br label %if.end.l22 if.else.l22: ; preds = %for.l21 - %68 = load i64, ptr %q, align 8 - %69 = load i64, ptr %k, align 8 - %70 = mul i64 %68, %69 - %71 = alloca i64, align 8 - store i64 %70, ptr %71, align 8 - %72 = load i64, ptr %71, align 8 - store i64 %72, ptr %q_new, align 8 - %73 = load i64, ptr %q, align 8 - %74 = mul i64 2, %73 - %75 = alloca i64, align 8 - store i64 %74, ptr %75, align 8 - %76 = load i64, ptr %75, align 8 - %77 = load i64, ptr %r, align 8 - %78 = add i64 %76, %77 - %79 = alloca i64, align 8 - store i64 %78, ptr %79, align 8 - %80 = load i64, ptr %79, align 8 - %81 = load i64, ptr %x, align 8 - %82 = mul i64 %80, %81 - %83 = alloca i64, align 8 - store i64 %82, ptr %83, align 8 - %84 = load i64, ptr %83, align 8 - store i64 %84, ptr %r_new, align 8 - %85 = load i64, ptr %t, align 8 - %86 = load i64, ptr %x, align 8 - %87 = mul i64 %85, %86 - %88 = alloca i64, align 8 - store i64 %87, ptr %88, align 8 - %89 = load i64, ptr %88, align 8 - store i64 %89, ptr %t_new, align 8 - %90 = load i64, ptr %k, align 8 - %91 = add i64 %90, 1 - %92 = alloca i64, align 8 - store i64 %91, ptr %92, align 8 - %93 = load i64, ptr %92, align 8 - store i64 %93, ptr %k_new, align 8 - %94 = load i64, ptr %q, align 8 - %95 = load i64, ptr %k, align 8 - %96 = mul i64 7, %95 - %97 = alloca i64, align 8 - store i64 %96, ptr %97, align 8 - %98 = load i64, ptr %97, align 8 - %99 = add i64 %98, 2 - %100 = alloca i64, align 8 - store i64 %99, ptr %100, align 8 - %101 = load i64, ptr %100, align 8 - %102 = mul i64 %94, %101 - %103 = alloca i64, align 8 - store i64 %102, ptr %103, align 8 - %104 = load i64, ptr %103, align 8 - %105 = load i64, ptr %r, align 8 - %106 = load i64, ptr %x, align 8 - %107 = mul i64 %105, %106 - %108 = alloca i64, align 8 - store i64 %107, ptr %108, align 8 - %109 = load i64, ptr %108, align 8 - %110 = add i64 %104, %109 - %111 = alloca i64, align 8 - store i64 %110, ptr %111, align 8 - %112 = load i64, ptr %111, align 8 - %113 = load i64, ptr %t, align 8 - %114 = load i64, ptr %x, align 8 - %115 = mul i64 %113, %114 - %116 = alloca i64, align 8 - store i64 %115, ptr %116, align 8 - %117 = load i64, ptr %116, align 8 - %118 = sdiv i64 %112, %117 - %119 = alloca i64, align 8 - store i64 %118, ptr %119, align 8 - %120 = load i64, ptr %119, align 8 - store i64 %120, ptr %m, align 8 + %102 = load i64, ptr %q, align 8 + %103 = load i64, ptr %k, align 8 + %104 = mul i64 %102, %103 + store i64 %104, ptr %20, align 8 + %105 = load i64, ptr %20, align 8 + store i64 %105, ptr %q_new, align 8 + %106 = load i64, ptr %q, align 8 + store i64 2, ptr %r_new8, align 8 + %107 = mul i64 2, %106 + store i64 %107, ptr %21, align 8 + %108 = load i64, ptr %21, align 8 + %109 = load i64, ptr %r, align 8 + %110 = add i64 %108, %109 + store i64 %110, ptr %22, align 8 + %111 = load i64, ptr %22, align 8 + %112 = load i64, ptr %x, align 8 + %113 = load i64, ptr %q, align 8 + store i64 2, ptr %r_new9, align 8 + %114 = mul i64 2, %113 + store i64 %114, ptr %23, align 8 + %115 = load i64, ptr %23, align 8 + %116 = load i64, ptr %r, align 8 + %117 = add i64 %115, %116 + store i64 %117, ptr %24, align 8 + %118 = mul i64 %111, %112 + store i64 %118, ptr %25, align 8 + %119 = load i64, ptr %25, align 8 + store i64 %119, ptr %r_new, align 8 + %120 = load i64, ptr %t, align 8 %121 = load i64, ptr %x, align 8 - %122 = add i64 %121, 2 - store i64 %122, ptr %x, align 8 - %123 = load i64, ptr %q_new, align 8 - store i64 %123, ptr %q, align 8 - %124 = load i64, ptr %r_new, align 8 - store i64 %124, ptr %r, align 8 - %125 = load i64, ptr %t_new, align 8 - store i64 %125, ptr %t, align 8 - %126 = load i64, ptr %k_new, align 8 - store i64 %126, ptr %k, align 8 + %122 = mul i64 %120, %121 + store i64 %122, ptr %26, align 8 + %123 = load i64, ptr %26, align 8 + store i64 %123, ptr %t_new, align 8 + %124 = load i64, ptr %k, align 8 + %125 = add i64 %124, 1 + store i64 %125, ptr %27, align 8 + %126 = load i64, ptr %27, align 8 + store i64 %126, ptr %k_new, align 8 + %127 = load i64, ptr %q, align 8 + %128 = load i64, ptr %k, align 8 + store i64 7, ptr %m10, align 8 + %129 = mul i64 7, %128 + store i64 %129, ptr %28, align 8 + %130 = load i64, ptr %28, align 8 + %131 = add i64 %130, 2 + store i64 %131, ptr %29, align 8 + %132 = load i64, ptr %29, align 8 + %133 = load i64, ptr %k, align 8 + store i64 7, ptr %m11, align 8 + %134 = mul i64 7, %133 + store i64 %134, ptr %30, align 8 + %135 = load i64, ptr %30, align 8 + %136 = add i64 %135, 2 + store i64 %136, ptr %31, align 8 + %137 = mul i64 %127, %132 + store i64 %137, ptr %32, align 8 + %138 = load i64, ptr %32, align 8 + %139 = load i64, ptr %r, align 8 + %140 = load i64, ptr %x, align 8 + %141 = mul i64 %139, %140 + store i64 %141, ptr %33, align 8 + %142 = load i64, ptr %33, align 8 + %143 = add i64 %138, %142 + store i64 %143, ptr %34, align 8 + %144 = load i64, ptr %34, align 8 + %145 = load i64, ptr %t, align 8 + %146 = load i64, ptr %x, align 8 + %147 = mul i64 %145, %146 + store i64 %147, ptr %35, align 8 + %148 = load i64, ptr %35, align 8 + %149 = sdiv i64 %144, %148 + store i64 %149, ptr %36, align 8 + %150 = load i64, ptr %36, align 8 + store i64 %150, ptr %m, align 8 + %151 = load i64, ptr %x, align 8 + %152 = add i64 %151, 2 + store i64 %152, ptr %x, align 8 + %153 = load i64, ptr %q_new, align 8 + store i64 %153, ptr %q, align 8 + %154 = load i64, ptr %r_new, align 8 + store i64 %154, ptr %r, align 8 + %155 = load i64, ptr %t_new, align 8 + store i64 %155, ptr %t, align 8 + %156 = load i64, ptr %k_new, align 8 + store i64 %156, ptr %k, align 8 br label %if.end.l22 if.end.l22: ; preds = %if.else.l22, %if.end.l24 br label %for.inc.l21 for.inc.l21: ; preds = %if.end.l22 - %127 = load i32, ptr %i, align 4 - %128 = add i32 %127, 1 - store i32 %128, ptr %i, align 4 - %129 = alloca i32, align 4 - store i32 %127, ptr %129, align 4 + %157 = load i32, ptr %i, align 4 + %158 = add i32 %157, 1 + store i32 %158, ptr %i, align 4 + store i32 %157, ptr %37, align 4 br label %for.cond.l21 for.cond.l21: ; preds = %for.inc.l21, %entry.l4 - %130 = load i32, ptr %i, align 4 - %131 = load i32, ptr %iterations, align 4 - %132 = icmp slt i32 %130, %131 - %133 = alloca i1, align 1 - store i1 %132, ptr %133, align 1 - %134 = load i1, ptr %133, align 1 - br i1 %134, label %for.l21, label %for.end.l21 + %159 = load i32, ptr %i, align 4 + %160 = load i32, ptr %iterations, align 4 + %161 = icmp slt i32 %159, %160 + store i1 %161, ptr %38, align 1 + %162 = load i1, ptr %38, align 1 + br i1 %162, label %for.l21, label %for.end.l21 for.end.l21: ; preds = %for.cond.l21 - %135 = load i32, ptr %result, align 4 - ret i32 %135 + %163 = load i32, ptr %result, align 4 + ret i32 %163 } declare i32 @printf(ptr, ...) diff --git a/test/test-files/generator/arrays/success-arrays-dynamic-size/ir-code.ll b/test/test-files/generator/arrays/success-arrays-dynamic-size/ir-code.ll index 46a2853cd..62b9fe35e 100644 --- a/test/test-files/generator/arrays/success-arrays-dynamic-size/ir-code.ll +++ b/test/test-files/generator/arrays/success-arrays-dynamic-size/ir-code.ll @@ -18,9 +18,25 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 + %arraySize1 = alloca i16, align 2 + %array1 = alloca ptr, align 8 + %idx = alloca i32, align 4 + %item = alloca i32, align 4 + %arraySize2 = alloca i64, align 8 + %array2 = alloca ptr, align 8 + %idx2 = alloca i32, align 4 + %item3 = alloca ptr, align 8 + %arraySize3 = alloca i32, align 4 + %array3 = alloca ptr, align 8 + %idx6 = alloca i32, align 4 + %item7 = alloca i32, align 4 + %arraySize4 = alloca i32, align 4 + %array4 = alloca ptr, align 8 + %array410 = alloca ptr, align 8 + %idx11 = alloca i32, align 4 + %item12 = alloca i32, align 4 store i32 0, ptr %result, align 4 %0 = call i32 (ptr, ...) @printf(ptr @0) - %arraySize1 = alloca i16, align 2 store i16 4, ptr %arraySize1, align 2 %1 = load i16, ptr %arraySize1, align 2 %2 = call ptr @llvm.stacksave() @@ -31,14 +47,11 @@ entry.l1: store i32 2, ptr %5, align 4 %6 = getelementptr inbounds i32, ptr %3, i32 2 store i32 3, ptr %6, align 4 - %array1 = alloca ptr, align 8 store ptr %3, ptr %array1, align 8 %7 = load ptr, ptr %array1, align 8 %8 = getelementptr inbounds i32, ptr %7, i32 3 store i32 0, ptr %8, align 4 - %idx = alloca i32, align 4 store i32 0, ptr %idx, align 4 - %item = alloca i32, align 4 store i32 0, ptr %item, align 4 %9 = load ptr, ptr %array1, align 8 %10 = sext i16 %1 to i32 @@ -70,11 +83,9 @@ foreach.cond.l6: ; preds = %foreach.inc.l6 foreach.end.l6: ; preds = %foreach.cond.l6 %21 = call i32 (ptr, ...) @printf(ptr @2) - %arraySize2 = alloca i64, align 8 store i64 2, ptr %arraySize2, align 8 %22 = load i64, ptr %arraySize2, align 8 %23 = alloca ptr, i64 %22, align 8 - %array2 = alloca ptr, align 8 store ptr %23, ptr %array2, align 8 %24 = load ptr, ptr %array2, align 8 %25 = getelementptr inbounds ptr, ptr %24, i32 0 @@ -82,9 +93,7 @@ foreach.end.l6: ; preds = %foreach.cond.l6 %26 = load ptr, ptr %array2, align 8 %27 = getelementptr inbounds ptr, ptr %26, i32 1 store ptr @4, ptr %27, align 8 - %idx2 = alloca i32, align 4 store i32 0, ptr %idx2, align 4 - %item3 = alloca ptr, align 8 store ptr @5, ptr %item3, align 8 %28 = load ptr, ptr %array2, align 8 %29 = trunc i64 %22 to i32 @@ -116,7 +125,6 @@ foreach.cond.l15: ; preds = %foreach.inc.l15 foreach.end.l15: ; preds = %foreach.cond.l15 %40 = call i32 (ptr, ...) @printf(ptr @7) - %arraySize3 = alloca i32, align 4 store i32 3, ptr %arraySize3, align 4 %41 = load i32, ptr %arraySize3, align 4 %42 = load i32, ptr %arraySize3, align 4 @@ -128,11 +136,8 @@ foreach.end.l15: ; preds = %foreach.cond.l15 store i32 %42, ptr %46, align 4 %47 = getelementptr inbounds i32, ptr %44, i32 2 store i32 %43, ptr %47, align 4 - %array3 = alloca ptr, align 8 store ptr %44, ptr %array3, align 8 - %idx6 = alloca i32, align 4 store i32 0, ptr %idx6, align 4 - %item7 = alloca i32, align 4 store i32 0, ptr %item7, align 4 %48 = load ptr, ptr %array3, align 8 %49 = load i32, ptr %idx6, align 4 @@ -163,11 +168,9 @@ foreach.cond.l22: ; preds = %foreach.inc.l22 foreach.end.l22: ; preds = %foreach.cond.l22 %59 = call i32 (ptr, ...) @printf(ptr @9) - %arraySize4 = alloca i32, align 4 store i32 3, ptr %arraySize4, align 4 %60 = load i32, ptr %arraySize4, align 4 %61 = alloca i32, i32 %60, align 4 - %array4 = alloca ptr, align 8 store ptr %61, ptr %array4, align 8 %62 = load i32, ptr %arraySize4, align 4 %63 = load i32, ptr %arraySize4, align 4 @@ -178,13 +181,10 @@ foreach.end.l22: ; preds = %foreach.cond.l22 store i32 %62, ptr %66, align 4 %67 = getelementptr inbounds i32, ptr %64, i32 2 store i32 %63, ptr %67, align 4 - %array410 = alloca ptr, align 8 store ptr %64, ptr %array410, align 8 %68 = load ptr, ptr %array410, align 8 store ptr %68, ptr %array4, align 8 - %idx11 = alloca i32, align 4 store i32 0, ptr %idx11, align 4 - %item12 = alloca i32, align 4 store i32 0, ptr %item12, align 4 %69 = load ptr, ptr %array4, align 8 %70 = load i32, ptr %idx11, align 4 diff --git a/test/test-files/generator/arrays/success-arrays-multidimensional/ir-code.ll b/test/test-files/generator/arrays/success-arrays-multidimensional/ir-code.ll index ad6edaa1c..73bbf0b0f 100644 --- a/test/test-files/generator/arrays/success-arrays-multidimensional/ir-code.ll +++ b/test/test-files/generator/arrays/success-arrays-multidimensional/ir-code.ll @@ -8,65 +8,65 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %a = alloca [10 x [10 x i32]], align 4 - store [10 x [10 x i32]] zeroinitializer, ptr %a, align 4 %i = alloca i32, align 4 + %j = alloca i32, align 4 + %0 = alloca i32, align 4 + %1 = alloca i32, align 4 + %2 = alloca i1, align 1 + %3 = alloca i32, align 4 + %4 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + store [10 x [10 x i32]] zeroinitializer, ptr %a, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l3 for.l3: ; preds = %for.cond.l3 - %j = alloca i32, align 4 store i32 0, ptr %j, align 4 br label %for.cond.l4 for.l4: ; preds = %for.cond.l4 - %0 = load i32, ptr %i, align 4 - %1 = load i32, ptr %j, align 4 - %2 = mul i32 %0, %1 - %3 = alloca i32, align 4 - store i32 %2, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 %5 = load i32, ptr %i, align 4 - %6 = getelementptr inbounds [10 x [10 x i32]], ptr %a, i32 0, i32 %5 - %7 = load i32, ptr %j, align 4 - %8 = getelementptr inbounds [10 x i32], ptr %6, i32 0, i32 %7 - store i32 %4, ptr %8, align 4 + %6 = load i32, ptr %j, align 4 + %7 = mul i32 %5, %6 + store i32 %7, ptr %0, align 4 + %8 = load i32, ptr %0, align 4 + %9 = load i32, ptr %i, align 4 + %10 = getelementptr inbounds [10 x [10 x i32]], ptr %a, i32 0, i32 %9 + %11 = load i32, ptr %j, align 4 + %12 = getelementptr inbounds [10 x i32], ptr %10, i32 0, i32 %11 + store i32 %8, ptr %12, align 4 br label %for.inc.l4 for.inc.l4: ; preds = %for.l4 - %9 = load i32, ptr %j, align 4 - %10 = add i32 %9, 1 - store i32 %10, ptr %j, align 4 - %11 = alloca i32, align 4 - store i32 %9, ptr %11, align 4 + %13 = load i32, ptr %j, align 4 + %14 = add i32 %13, 1 + store i32 %14, ptr %j, align 4 + store i32 %13, ptr %1, align 4 br label %for.cond.l4 for.cond.l4: ; preds = %for.inc.l4, %for.l3 - %12 = load i32, ptr %j, align 4 - %13 = icmp slt i32 %12, 10 - %14 = alloca i1, align 1 - store i1 %13, ptr %14, align 1 - %15 = load i1, ptr %14, align 1 - br i1 %15, label %for.l4, label %for.end.l4 + %15 = load i32, ptr %j, align 4 + %16 = icmp slt i32 %15, 10 + store i1 %16, ptr %2, align 1 + %17 = load i1, ptr %2, align 1 + br i1 %17, label %for.l4, label %for.end.l4 for.end.l4: ; preds = %for.cond.l4 br label %for.inc.l3 for.inc.l3: ; preds = %for.end.l4 - %16 = load i32, ptr %i, align 4 - %17 = add i32 %16, 1 - store i32 %17, ptr %i, align 4 - %18 = alloca i32, align 4 - store i32 %16, ptr %18, align 4 + %18 = load i32, ptr %i, align 4 + %19 = add i32 %18, 1 + store i32 %19, ptr %i, align 4 + store i32 %18, ptr %3, align 4 br label %for.cond.l3 for.cond.l3: ; preds = %for.inc.l3, %entry.l1 - %19 = load i32, ptr %i, align 4 - %20 = icmp slt i32 %19, 10 - %21 = alloca i1, align 1 - store i1 %20, ptr %21, align 1 - %22 = load i1, ptr %21, align 1 + %20 = load i32, ptr %i, align 4 + %21 = icmp slt i32 %20, 10 + store i1 %21, ptr %4, align 1 + %22 = load i1, ptr %4, align 1 br i1 %22, label %for.l3, label %for.end.l3 for.end.l3: ; preds = %for.cond.l3 diff --git a/test/test-files/generator/arrays/success-arrays/ir-code.ll b/test/test-files/generator/arrays/success-arrays/ir-code.ll index 7746beaae..c9e72ea10 100644 --- a/test/test-files/generator/arrays/success-arrays/ir-code.ll +++ b/test/test-files/generator/arrays/success-arrays/ir-code.ll @@ -8,30 +8,30 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %value0 = alloca i32, align 4 + %0 = alloca [5 x i32], align 4 + store i32 0, ptr %result, align 4 store i32 2, ptr %value0, align 4 - %0 = load i32, ptr %value0, align 4 - %1 = alloca [5 x i32], align 4 - %2 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 0 - store i32 %0, ptr %2, align 4 - %3 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 1 + %1 = load i32, ptr %value0, align 4 + %2 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 0 + store i32 %1, ptr %2, align 4 + %3 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 1 store i32 7, ptr %3, align 4 - %4 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 2 + %4 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 2 store i32 4, ptr %4, align 4 - %5 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 3 + %5 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 3 store i32 0, ptr %5, align 4 - %6 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 4 + %6 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 4 store i32 0, ptr %6, align 4 - %7 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 2 + %7 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 2 %8 = load i32, ptr %7, align 4 %9 = mul i32 %8, 11 store i32 %9, ptr %7, align 4 - %10 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 0 + %10 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 0 store i32 3, ptr %10, align 4 - %11 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 0 + %11 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 0 %12 = load i32, ptr %11, align 4 - %13 = getelementptr inbounds [5 x i32], ptr %1, i32 0, i32 2 + %13 = getelementptr inbounds [5 x i32], ptr %0, i32 0, i32 2 %14 = load i32, ptr %13, align 4 %15 = call i32 (ptr, ...) @printf(ptr @0, i32 %12, i32 %14) %16 = load i32, ptr %result, align 4 diff --git a/test/test-files/generator/arrays/success-arrays3/ir-code.ll b/test/test-files/generator/arrays/success-arrays3/ir-code.ll index f1fccfbf1..8e987422d 100644 --- a/test/test-files/generator/arrays/success-arrays3/ir-code.ll +++ b/test/test-files/generator/arrays/success-arrays3/ir-code.ll @@ -9,8 +9,8 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %intArray = alloca [2 x i32], align 4 + store i32 0, ptr %result, align 4 store [2 x i32] zeroinitializer, ptr %intArray, align 4 %0 = load [2 x i32], ptr @intArray, align 4 store [2 x i32] %0, ptr %intArray, align 4 diff --git a/test/test-files/generator/arrays/success-arrays4/ir-code.ll b/test/test-files/generator/arrays/success-arrays4/ir-code.ll index be323176b..20f0517f9 100644 --- a/test/test-files/generator/arrays/success-arrays4/ir-code.ll +++ b/test/test-files/generator/arrays/success-arrays4/ir-code.ll @@ -14,10 +14,10 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 - store i32 0, ptr %i, align 4 %word = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + store i32 0, ptr %i, align 4 store ptr @4, ptr %word, align 8 %0 = load [5 x ptr], ptr @welcomeMessage, align 8 %1 = load i32, ptr %i, align 4 diff --git a/test/test-files/generator/arrays/success-string-char-access/ir-code.ll b/test/test-files/generator/arrays/success-string-char-access/ir-code.ll index 83ef8ae6d..0c20e2763 100644 --- a/test/test-files/generator/arrays/success-string-char-access/ir-code.ll +++ b/test/test-files/generator/arrays/success-string-char-access/ir-code.ll @@ -9,8 +9,8 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %test = alloca ptr, align 8 + store i32 0, ptr %result, align 4 store ptr @0, ptr %test, align 8 %0 = load ptr, ptr %test, align 8 %1 = getelementptr inbounds i8, ptr %0, i32 2 diff --git a/test/test-files/generator/assertions/success-basic-assertion/ir-code.ll b/test/test-files/generator/assertions/success-basic-assertion/ir-code.ll index c8ae14855..e11fc004f 100644 --- a/test/test-files/generator/assertions/success-basic-assertion/ir-code.ll +++ b/test/test-files/generator/assertions/success-basic-assertion/ir-code.ll @@ -9,15 +9,15 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i1 false, ptr %0, align 1 %1 = load i1, ptr %0, align 1 br i1 %1, label %assert.end.l2, label %assert.then.l2 assert.then.l2: ; preds = %entry.l1 %2 = call i32 (ptr, ...) @printf(ptr @0) - call void @exit(i32 1) + call void @exit(i32 0) unreachable assert.end.l2: ; preds = %entry.l1 diff --git a/test/test-files/generator/builtins/success-len/ir-code.ll b/test/test-files/generator/builtins/success-len/ir-code.ll index f9a8a0267..15fdaebf7 100644 --- a/test/test-files/generator/builtins/success-len/ir-code.ll +++ b/test/test-files/generator/builtins/success-len/ir-code.ll @@ -9,11 +9,11 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 + %0 = alloca i32, align 4 store i32 0, ptr %result, align 4 - %0 = load [7 x i32], ptr @testIntArray, align 4 - %1 = alloca i32, align 4 - store i32 7, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %1 = load [7 x i32], ptr @testIntArray, align 4 + store i32 7, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/builtins/success-sizeof/ir-code.ll b/test/test-files/generator/builtins/success-sizeof/ir-code.ll index 996fd3807..3eb61aa3a 100644 --- a/test/test-files/generator/builtins/success-sizeof/ir-code.ll +++ b/test/test-files/generator/builtins/success-sizeof/ir-code.ll @@ -20,62 +20,62 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l7: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i32, align 4 - store i32 64, ptr %0, align 4 - %1 = load i32, ptr %0, align 4 - %2 = call i32 (ptr, ...) @printf(ptr @0, i32 %1) + %1 = alloca i32, align 4 + %2 = alloca i32, align 4 %3 = alloca i32, align 4 - store i32 32, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 - %5 = call i32 (ptr, ...) @printf(ptr @1, i32 %4) - %6 = alloca i32, align 4 - store i32 16, ptr %6, align 4 - %7 = load i32, ptr %6, align 4 - %8 = call i32 (ptr, ...) @printf(ptr @2, i32 %7) + %4 = alloca i8, align 1 + %5 = alloca i32, align 4 + %6 = alloca i8, align 1 + %7 = alloca i32, align 4 + %8 = alloca i32, align 4 %9 = alloca i32, align 4 - store i32 64, ptr %9, align 4 - %10 = load i32, ptr %9, align 4 - %11 = call i32 (ptr, ...) @printf(ptr @3, i32 %10) - %12 = alloca i8, align 1 - store i8 13, ptr %12, align 1 - %13 = load i8, ptr %12, align 1 - %14 = alloca i32, align 4 - store i32 8, ptr %14, align 4 - %15 = load i32, ptr %14, align 4 - %16 = call i32 (ptr, ...) @printf(ptr @4, i32 %15) - %17 = alloca i8, align 1 - store i8 65, ptr %17, align 1 - %18 = load i8, ptr %17, align 1 - %19 = alloca i32, align 4 - store i32 8, ptr %19, align 4 - %20 = load i32, ptr %19, align 4 - %21 = call i32 (ptr, ...) @printf(ptr @5, i32 %20) - %22 = alloca i32, align 4 - store i32 64, ptr %22, align 4 - %23 = load i32, ptr %22, align 4 - %24 = call i32 (ptr, ...) @printf(ptr @6, i32 %23) - %25 = alloca i32, align 4 - store i32 1, ptr %25, align 4 - %26 = load i32, ptr %25, align 4 - %27 = call i32 (ptr, ...) @printf(ptr @8, i32 %26) - %28 = load [7 x i32], ptr @anonymous.0, align 4 - %29 = alloca i32, align 4 - store i32 224, ptr %29, align 4 - %30 = load i32, ptr %29, align 4 - %31 = call i32 (ptr, ...) @printf(ptr @9, i32 %30) + %10 = alloca i32, align 4 %intVariable = alloca i32, align 4 + %11 = alloca ptr, align 8 + %12 = alloca i32, align 4 + %13 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 64, ptr %0, align 4 + %14 = load i32, ptr %0, align 4 + %15 = call i32 (ptr, ...) @printf(ptr @0, i32 %14) + store i32 32, ptr %1, align 4 + %16 = load i32, ptr %1, align 4 + %17 = call i32 (ptr, ...) @printf(ptr @1, i32 %16) + store i32 16, ptr %2, align 4 + %18 = load i32, ptr %2, align 4 + %19 = call i32 (ptr, ...) @printf(ptr @2, i32 %18) + store i32 64, ptr %3, align 4 + %20 = load i32, ptr %3, align 4 + %21 = call i32 (ptr, ...) @printf(ptr @3, i32 %20) + store i8 13, ptr %4, align 1 + %22 = load i8, ptr %4, align 1 + store i32 8, ptr %5, align 4 + %23 = load i32, ptr %5, align 4 + %24 = call i32 (ptr, ...) @printf(ptr @4, i32 %23) + store i8 65, ptr %6, align 1 + %25 = load i8, ptr %6, align 1 + store i32 8, ptr %7, align 4 + %26 = load i32, ptr %7, align 4 + %27 = call i32 (ptr, ...) @printf(ptr @5, i32 %26) + store i32 64, ptr %8, align 4 + %28 = load i32, ptr %8, align 4 + %29 = call i32 (ptr, ...) @printf(ptr @6, i32 %28) + store i32 1, ptr %9, align 4 + %30 = load i32, ptr %9, align 4 + %31 = call i32 (ptr, ...) @printf(ptr @8, i32 %30) + %32 = load [7 x i32], ptr @anonymous.0, align 4 + store i32 224, ptr %10, align 4 + %33 = load i32, ptr %10, align 4 + %34 = call i32 (ptr, ...) @printf(ptr @9, i32 %33) store i32 123, ptr %intVariable, align 4 - %32 = alloca ptr, align 8 - store ptr %intVariable, ptr %32, align 8 - %33 = load ptr, ptr %32, align 8 - %34 = alloca i32, align 4 - store i32 64, ptr %34, align 4 - %35 = load i32, ptr %34, align 4 - %36 = call i32 (ptr, ...) @printf(ptr @10, i32 %35) - %37 = alloca i32, align 4 - store i32 128, ptr %37, align 4 - %38 = load i32, ptr %37, align 4 + store ptr %intVariable, ptr %11, align 8 + %35 = load ptr, ptr %11, align 8 + store i32 64, ptr %12, align 4 + %36 = load i32, ptr %12, align 4 + %37 = call i32 (ptr, ...) @printf(ptr @10, i32 %36) + store i32 128, ptr %13, align 4 + %38 = load i32, ptr %13, align 4 %39 = call i32 (ptr, ...) @printf(ptr @11, i32 %38) %40 = load i32, ptr %result, align 4 ret i32 %40 diff --git a/test/test-files/generator/cli-args/success-cli-args/ir-code.ll b/test/test-files/generator/cli-args/success-cli-args/ir-code.ll index 457d1c0e7..46e79b2b8 100644 --- a/test/test-files/generator/cli-args/success-cli-args/ir-code.ll +++ b/test/test-files/generator/cli-args/success-cli-args/ir-code.ll @@ -10,22 +10,22 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main(i32 %0, ptr %1) { entry.l1: %argc = alloca i32, align 4 - store i32 %0, ptr %argc, align 4 %argv = alloca ptr, align 8 - store ptr %1, ptr %argv, align 8 %result = alloca i32, align 4 + %2 = alloca i1, align 1 + store i32 %0, ptr %argc, align 4 + store ptr %1, ptr %argv, align 8 store i32 0, ptr %result, align 4 - %2 = load i32, ptr %argc, align 4 - %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2) - %4 = load ptr, ptr %argv, align 8 - %5 = getelementptr inbounds ptr, ptr %4, i32 0 - %6 = load ptr, ptr %5, align 8 - %7 = call i32 (ptr, ...) @printf(ptr @1, ptr %6) - %8 = load i32, ptr %argc, align 4 - %9 = icmp sgt i32 %8, 1 - %10 = alloca i1, align 1 - store i1 %9, ptr %10, align 1 - %11 = load i1, ptr %10, align 1 + %3 = load i32, ptr %argc, align 4 + %4 = call i32 (ptr, ...) @printf(ptr @0, i32 %3) + %5 = load ptr, ptr %argv, align 8 + %6 = getelementptr inbounds ptr, ptr %5, i32 0 + %7 = load ptr, ptr %6, align 8 + %8 = call i32 (ptr, ...) @printf(ptr @1, ptr %7) + %9 = load i32, ptr %argc, align 4 + %10 = icmp sgt i32 %9, 1 + store i1 %10, ptr %2, align 1 + %11 = load i1, ptr %2, align 1 br i1 %11, label %if.then.l4, label %if.end.l4 if.then.l4: ; preds = %entry.l1 diff --git a/test/test-files/generator/enums/success-enums/ir-code.ll b/test/test-files/generator/enums/success-enums/ir-code.ll index a96325de6..280da90ee 100644 --- a/test/test-files/generator/enums/success-enums/ir-code.ll +++ b/test/test-files/generator/enums/success-enums/ir-code.ll @@ -8,8 +8,8 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l9: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i32 12, ptr %0, align 4 %1 = load i32, ptr %0, align 4 %2 = call i32 (ptr, ...) @printf(ptr @0, i32 %1) diff --git a/test/test-files/generator/ext-decl/success-ext-decl/ir-code.ll b/test/test-files/generator/ext-decl/success-ext-decl/ir-code.ll index 8e0dfbcd5..da27e382c 100644 --- a/test/test-files/generator/ext-decl/success-ext-decl/ir-code.ll +++ b/test/test-files/generator/ext-decl/success-ext-decl/ir-code.ll @@ -19,25 +19,25 @@ declare void @free(ptr) define i32 @main() { entry.l7: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @0) - %1 = alloca ptr, align 8 - store ptr @1, ptr %1, align 8 - %2 = load ptr, ptr %1, align 8 - %3 = load i32, ptr @MODE_ALL_RWX, align 4 + %0 = alloca ptr, align 8 + %1 = alloca i32, align 4 + %2 = alloca i32, align 4 + %3 = alloca ptr, align 8 %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 - %5 = load i32, ptr %4, align 4 - %6 = call i32 @mkdir(ptr %2, i32 %5) - %7 = alloca i32, align 4 - store i32 %6, ptr %7, align 4 - %8 = call i32 (ptr, ...) @printf(ptr @2) - %9 = alloca ptr, align 8 - store ptr @3, ptr %9, align 8 - %10 = load ptr, ptr %9, align 8 - %11 = call i32 @rmdir(ptr %10) - %12 = alloca i32, align 4 - store i32 %11, ptr %12, align 4 + store i32 0, ptr %result, align 4 + %5 = call i32 (ptr, ...) @printf(ptr @0) + store ptr @1, ptr %0, align 8 + %6 = load ptr, ptr %0, align 8 + %7 = load i32, ptr @MODE_ALL_RWX, align 4 + store i32 %7, ptr %1, align 4 + %8 = load i32, ptr %1, align 4 + %9 = call i32 @mkdir(ptr %6, i32 %8) + store i32 %9, ptr %2, align 4 + %10 = call i32 (ptr, ...) @printf(ptr @2) + store ptr @3, ptr %3, align 8 + %11 = load ptr, ptr %3, align 8 + %12 = call i32 @rmdir(ptr %11) + store i32 %12, ptr %4, align 4 %13 = call i32 (ptr, ...) @printf(ptr @4) %14 = load i32, ptr %result, align 4 ret i32 %14 diff --git a/test/test-files/generator/for-loops/success-for-loop-break/ir-code-O2.ll b/test/test-files/generator/for-loops/success-for-loop-break/ir-code-O2.ll index 97b3eb920..0aaf5be96 100644 --- a/test/test-files/generator/for-loops/success-for-loop-break/ir-code-O2.ll +++ b/test/test-files/generator/for-loops/success-for-loop-break/ir-code-O2.ll @@ -13,17 +13,17 @@ entry.l1: br label %for.l2 for.l2: ; preds = %for.l2, %entry.l1 - %counter.06 = phi i32 [ 0, %entry.l1 ], [ %2, %for.l2 ] - %0 = tail call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %counter.06) - %1 = icmp ugt i32 %counter.06, 9000 - %2 = add nuw nsw i32 %counter.06, 2 + %counter.012 = phi i32 [ 0, %entry.l1 ], [ %2, %for.l2 ] + %0 = tail call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %counter.012) + %1 = icmp ugt i32 %counter.012, 9000 + %2 = add nuw nsw i32 %counter.012, 2 br i1 %1, label %for.l5, label %for.l2 for.l5: ; preds = %for.l2, %for.l5 - %storemerge5 = phi i32 [ %5, %for.l5 ], [ 100, %for.l2 ] - %3 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %storemerge5) - %4 = icmp eq i32 %storemerge5, 11 - %5 = add nsw i32 %storemerge5, -1 + %subCounter.011 = phi i32 [ %5, %for.l5 ], [ 100, %for.l2 ] + %3 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %subCounter.011) + %4 = icmp eq i32 %subCounter.011, 11 + %5 = add nsw i32 %subCounter.011, -1 br i1 %4, label %for.end.l2, label %for.l5 for.end.l2: ; preds = %for.l5 diff --git a/test/test-files/generator/for-loops/success-for-loop-break/ir-code.ll b/test/test-files/generator/for-loops/success-for-loop-break/ir-code.ll index 373f4c94a..e0a812a19 100644 --- a/test/test-files/generator/for-loops/success-for-loop-break/ir-code.ll +++ b/test/test-files/generator/for-loops/success-for-loop-break/ir-code.ll @@ -10,35 +10,37 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %counter = alloca i32, align 4 + %0 = alloca i1, align 1 + %subCounter = alloca i32, align 4 + %1 = alloca i1, align 1 + %2 = alloca i1, align 1 + %3 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i32 0, ptr %counter, align 4 br label %for.cond.l2 for.l2: ; preds = %for.cond.l2 - %0 = load i32, ptr %counter, align 4 - %1 = call i32 (ptr, ...) @printf(ptr @0, i32 %0) - %2 = load i32, ptr %counter, align 4 - %3 = icmp sge i32 %2, 9001 - %4 = alloca i1, align 1 - store i1 %3, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 - br i1 %5, label %if.then.l4, label %if.end.l4 + %4 = load i32, ptr %counter, align 4 + %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) + %6 = load i32, ptr %counter, align 4 + %7 = icmp sge i32 %6, 9001 + store i1 %7, ptr %0, align 1 + %8 = load i1, ptr %0, align 1 + br i1 %8, label %if.then.l4, label %if.end.l4 if.then.l4: ; preds = %for.l2 - %subCounter = alloca i32, align 4 store i32 100, ptr %subCounter, align 4 br label %for.cond.l5 for.l5: ; preds = %for.cond.l5 - %6 = load i32, ptr %subCounter, align 4 - %7 = call i32 (ptr, ...) @printf(ptr @1, i32 %6) - %8 = load i32, ptr %subCounter, align 4 - %9 = icmp eq i32 %8, 11 - %10 = alloca i1, align 1 - store i1 %9, ptr %10, align 1 - %11 = load i1, ptr %10, align 1 - br i1 %11, label %if.then.l7, label %if.end.l7 + %9 = load i32, ptr %subCounter, align 4 + %10 = call i32 (ptr, ...) @printf(ptr @1, i32 %9) + %11 = load i32, ptr %subCounter, align 4 + %12 = icmp eq i32 %11, 11 + store i1 %12, ptr %1, align 1 + %13 = load i1, ptr %1, align 1 + br i1 %13, label %if.then.l7, label %if.end.l7 if.then.l7: ; preds = %for.l5 br label %for.end.l2 @@ -47,18 +49,17 @@ if.end.l7: ; preds = %for.l5 br label %for.inc.l5 for.inc.l5: ; preds = %if.end.l7 - %12 = load i32, ptr %subCounter, align 4 - %13 = sub i32 %12, 1 - store i32 %13, ptr %subCounter, align 4 + %14 = load i32, ptr %subCounter, align 4 + %15 = sub i32 %14, 1 + store i32 %15, ptr %subCounter, align 4 br label %for.cond.l5 for.cond.l5: ; preds = %for.inc.l5, %if.then.l4 - %14 = load i32, ptr %subCounter, align 4 - %15 = icmp sge i32 %14, 10 - %16 = alloca i1, align 1 - store i1 %15, ptr %16, align 1 - %17 = load i1, ptr %16, align 1 - br i1 %17, label %for.l5, label %for.end.l5 + %16 = load i32, ptr %subCounter, align 4 + %17 = icmp sge i32 %16, 10 + store i1 %17, ptr %2, align 1 + %18 = load i1, ptr %2, align 1 + br i1 %18, label %for.l5, label %for.end.l5 for.end.l5: ; preds = %for.cond.l5 br label %if.end.l4 @@ -67,17 +68,16 @@ if.end.l4: ; preds = %for.end.l5, %for.l2 br label %for.inc.l2 for.inc.l2: ; preds = %if.end.l4 - %18 = load i32, ptr %counter, align 4 - %19 = add i32 %18, 2 - store i32 %19, ptr %counter, align 4 + %19 = load i32, ptr %counter, align 4 + %20 = add i32 %19, 2 + store i32 %20, ptr %counter, align 4 br label %for.cond.l2 for.cond.l2: ; preds = %for.inc.l2, %entry.l1 - %20 = load i32, ptr %counter, align 4 - %21 = icmp slt i32 %20, 10000 - %22 = alloca i1, align 1 - store i1 %21, ptr %22, align 1 - %23 = load i1, ptr %22, align 1 + %21 = load i32, ptr %counter, align 4 + %22 = icmp slt i32 %21, 10000 + store i1 %22, ptr %3, align 1 + %23 = load i1, ptr %3, align 1 br i1 %23, label %for.l2, label %for.end.l2 for.end.l2: ; preds = %for.cond.l2, %if.then.l7 diff --git a/test/test-files/generator/for-loops/success-for-loop-continue/ir-code-O2.ll b/test/test-files/generator/for-loops/success-for-loop-continue/ir-code-O2.ll index c8c3f979a..e5851a2b3 100644 --- a/test/test-files/generator/for-loops/success-for-loop-continue/ir-code-O2.ll +++ b/test/test-files/generator/for-loops/success-for-loop-continue/ir-code-O2.ll @@ -17,10 +17,10 @@ for.l5.preheader.3: br label %for.l5.3 for.l5.3: ; preds = %for.l5.3, %for.l5.preheader.3 - %storemerge4.3 = phi i32 [ %5, %for.l5.3 ], [ 100, %for.l5.preheader.3 ] - %4 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %storemerge4.3) - %5 = add nsw i32 %storemerge4.3, -1 - %6 = add nsw i32 %storemerge4.3, -12 + %subCounter.010.3 = phi i32 [ %5, %for.l5.3 ], [ 100, %for.l5.preheader.3 ] + %4 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %subCounter.010.3) + %5 = add nsw i32 %subCounter.010.3, -1 + %6 = add nsw i32 %subCounter.010.3, -12 %7 = icmp ult i32 %6, -11 br i1 %7, label %for.l5.3, label %for.l5.preheader.4 @@ -29,10 +29,10 @@ for.l5.preheader.4: ; preds = %for.l5.3 br label %for.l5.4 for.l5.4: ; preds = %for.l5.4, %for.l5.preheader.4 - %storemerge4.4 = phi i32 [ %10, %for.l5.4 ], [ 100, %for.l5.preheader.4 ] - %9 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %storemerge4.4) - %10 = add nsw i32 %storemerge4.4, -1 - %11 = add nsw i32 %storemerge4.4, -12 + %subCounter.010.4 = phi i32 [ %10, %for.l5.4 ], [ 100, %for.l5.preheader.4 ] + %9 = tail call i32 (ptr, ...) @printf(ptr nonnull @1, i32 %subCounter.010.4) + %10 = add nsw i32 %subCounter.010.4, -1 + %11 = add nsw i32 %subCounter.010.4, -12 %12 = icmp ult i32 %11, -11 br i1 %12, label %for.l5.4, label %for.inc.l2.4 diff --git a/test/test-files/generator/for-loops/success-for-loop-continue/ir-code.ll b/test/test-files/generator/for-loops/success-for-loop-continue/ir-code.ll index 313d8b952..d4820f8f9 100644 --- a/test/test-files/generator/for-loops/success-for-loop-continue/ir-code.ll +++ b/test/test-files/generator/for-loops/success-for-loop-continue/ir-code.ll @@ -10,35 +10,37 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %counter = alloca i32, align 4 + %0 = alloca i1, align 1 + %subCounter = alloca i32, align 4 + %1 = alloca i1, align 1 + %2 = alloca i1, align 1 + %3 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i32 0, ptr %counter, align 4 br label %for.cond.l2 for.l2: ; preds = %for.cond.l2 - %0 = load i32, ptr %counter, align 4 - %1 = call i32 (ptr, ...) @printf(ptr @0, i32 %0) - %2 = load i32, ptr %counter, align 4 - %3 = icmp sge i32 %2, 5 - %4 = alloca i1, align 1 - store i1 %3, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 - br i1 %5, label %if.then.l4, label %if.end.l4 + %4 = load i32, ptr %counter, align 4 + %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) + %6 = load i32, ptr %counter, align 4 + %7 = icmp sge i32 %6, 5 + store i1 %7, ptr %0, align 1 + %8 = load i1, ptr %0, align 1 + br i1 %8, label %if.then.l4, label %if.end.l4 if.then.l4: ; preds = %for.l2 - %subCounter = alloca i32, align 4 store i32 100, ptr %subCounter, align 4 br label %for.cond.l5 for.l5: ; preds = %for.cond.l5 - %6 = load i32, ptr %subCounter, align 4 - %7 = call i32 (ptr, ...) @printf(ptr @1, i32 %6) - %8 = load i32, ptr %subCounter, align 4 - %9 = icmp eq i32 %8, 11 - %10 = alloca i1, align 1 - store i1 %9, ptr %10, align 1 - %11 = load i1, ptr %10, align 1 - br i1 %11, label %if.then.l7, label %if.end.l7 + %9 = load i32, ptr %subCounter, align 4 + %10 = call i32 (ptr, ...) @printf(ptr @1, i32 %9) + %11 = load i32, ptr %subCounter, align 4 + %12 = icmp eq i32 %11, 11 + store i1 %12, ptr %1, align 1 + %13 = load i1, ptr %1, align 1 + br i1 %13, label %if.then.l7, label %if.end.l7 if.then.l7: ; preds = %for.l5 br label %for.inc.l2 @@ -47,18 +49,17 @@ if.end.l7: ; preds = %for.l5 br label %for.inc.l5 for.inc.l5: ; preds = %if.end.l7 - %12 = load i32, ptr %subCounter, align 4 - %13 = sub i32 %12, 1 - store i32 %13, ptr %subCounter, align 4 + %14 = load i32, ptr %subCounter, align 4 + %15 = sub i32 %14, 1 + store i32 %15, ptr %subCounter, align 4 br label %for.cond.l5 for.cond.l5: ; preds = %for.inc.l5, %if.then.l4 - %14 = load i32, ptr %subCounter, align 4 - %15 = icmp sge i32 %14, 10 - %16 = alloca i1, align 1 - store i1 %15, ptr %16, align 1 - %17 = load i1, ptr %16, align 1 - br i1 %17, label %for.l5, label %for.end.l5 + %16 = load i32, ptr %subCounter, align 4 + %17 = icmp sge i32 %16, 10 + store i1 %17, ptr %2, align 1 + %18 = load i1, ptr %2, align 1 + br i1 %18, label %for.l5, label %for.end.l5 for.end.l5: ; preds = %for.cond.l5 br label %if.end.l4 @@ -67,17 +68,16 @@ if.end.l4: ; preds = %for.end.l5, %for.l2 br label %for.inc.l2 for.inc.l2: ; preds = %if.end.l4, %if.then.l7 - %18 = load i32, ptr %counter, align 4 - %19 = add i32 %18, 2 - store i32 %19, ptr %counter, align 4 + %19 = load i32, ptr %counter, align 4 + %20 = add i32 %19, 2 + store i32 %20, ptr %counter, align 4 br label %for.cond.l2 for.cond.l2: ; preds = %for.inc.l2, %entry.l1 - %20 = load i32, ptr %counter, align 4 - %21 = icmp slt i32 %20, 10 - %22 = alloca i1, align 1 - store i1 %21, ptr %22, align 1 - %23 = load i1, ptr %22, align 1 + %21 = load i32, ptr %counter, align 4 + %22 = icmp slt i32 %21, 10 + store i1 %22, ptr %3, align 1 + %23 = load i1, ptr %3, align 1 br i1 %23, label %for.l2, label %for.end.l2 for.end.l2: ; preds = %for.cond.l2 diff --git a/test/test-files/generator/for-loops/success-for-loop/ir-code.ll b/test/test-files/generator/for-loops/success-for-loop/ir-code.ll index caaa4f9e5..75c578b9c 100644 --- a/test/test-files/generator/for-loops/success-for-loop/ir-code.ll +++ b/test/test-files/generator/for-loops/success-for-loop/ir-code.ll @@ -8,28 +8,28 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 + %0 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l2 for.l2: ; preds = %for.cond.l2 - %0 = load i32, ptr %i, align 4 - %1 = call i32 (ptr, ...) @printf(ptr @0, i32 %0) + %1 = load i32, ptr %i, align 4 + %2 = call i32 (ptr, ...) @printf(ptr @0, i32 %1) br label %for.inc.l2 for.inc.l2: ; preds = %for.l2 - %2 = load i32, ptr %i, align 4 - %3 = add i32 %2, 2 - store i32 %3, ptr %i, align 4 + %3 = load i32, ptr %i, align 4 + %4 = add i32 %3, 2 + store i32 %4, ptr %i, align 4 br label %for.cond.l2 for.cond.l2: ; preds = %for.inc.l2, %entry.l1 - %4 = load i32, ptr %i, align 4 - %5 = icmp slt i32 %4, 10 - %6 = alloca i1, align 1 - store i1 %5, ptr %6, align 1 - %7 = load i1, ptr %6, align 1 + %5 = load i32, ptr %i, align 4 + %6 = icmp slt i32 %5, 10 + store i1 %6, ptr %0, align 1 + %7 = load i1, ptr %0, align 1 br i1 %7, label %for.l2, label %for.end.l2 for.end.l2: ; preds = %for.cond.l2 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-array-in-place/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-array-in-place/ir-code.ll index 9b03353be..35f864dc3 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-array-in-place/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-array-in-place/ir-code.ll @@ -9,10 +9,10 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %idx = alloca i32, align 4 - store i32 0, ptr %idx, align 4 %item = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 0, ptr %idx, align 4 store i32 0, ptr %item, align 4 %0 = load [5 x i32], ptr @anonymous.0, align 4 %1 = load i32, ptr %idx, align 4 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-break/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-break/ir-code.ll index 0a566da92..8ec9fdf9f 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-break/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-break/ir-code.ll @@ -11,52 +11,52 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %s1 = alloca i16, align 2 - store i16 5, ptr %s1, align 2 - %0 = load i16, ptr %s1, align 2 - %1 = alloca [5 x i16], align 2 - %2 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 0 - store i16 1, ptr %2, align 2 - %3 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 1 - store i16 %0, ptr %3, align 2 - %4 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 2 - store i16 25, ptr %4, align 2 - %5 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 3 - store i16 -27, ptr %5, align 2 - %6 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 4 - store i16 -63, ptr %6, align 2 + %0 = alloca [5 x i16], align 2 %idx = alloca i32, align 4 - store i32 0, ptr %idx, align 4 %s = alloca i16, align 2 + %1 = alloca i16, align 2 + %2 = alloca i1, align 1 + %idx1 = alloca i32, align 4 + %l = alloca i64, align 8 + store i32 0, ptr %result, align 4 + store i16 5, ptr %s1, align 2 + %3 = load i16, ptr %s1, align 2 + %4 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 0 + store i16 1, ptr %4, align 2 + %5 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 1 + store i16 %3, ptr %5, align 2 + %6 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 2 + store i16 25, ptr %6, align 2 + %7 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 3 + store i16 -27, ptr %7, align 2 + %8 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 4 + store i16 -63, ptr %8, align 2 + store i32 0, ptr %idx, align 4 store i16 0, ptr %s, align 2 - %7 = load [5 x i16], ptr %1, align 2 - %8 = load i32, ptr %idx, align 4 - %9 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 %8 - %10 = load i16, ptr %9, align 2 - store i16 %10, ptr %s, align 2 + %9 = load [5 x i16], ptr %0, align 2 + %10 = load i32, ptr %idx, align 4 + %11 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 %10 + %12 = load i16, ptr %11, align 2 + store i16 %12, ptr %s, align 2 br label %foreach.loop.l4 foreach.loop.l4: ; preds = %foreach.cond.l4, %entry.l1 - %11 = load i16, ptr %s, align 2 - %12 = sext i16 %11 to i32 - %13 = call i32 (ptr, ...) @printf(ptr @0, i32 %12) - %14 = load i16, ptr %s, align 2 - %15 = and i16 %14, 1 - %16 = alloca i16, align 2 - store i16 %15, ptr %16, align 2 - %17 = load i16, ptr %16, align 2 - %18 = sext i16 %17 to i32 - %19 = icmp eq i32 %18, 1 - %20 = alloca i1, align 1 - store i1 %19, ptr %20, align 1 - %21 = load i1, ptr %20, align 1 + %13 = load i16, ptr %s, align 2 + %14 = sext i16 %13 to i32 + %15 = call i32 (ptr, ...) @printf(ptr @0, i32 %14) + %16 = load i16, ptr %s, align 2 + %17 = and i16 %16, 1 + store i16 %17, ptr %1, align 2 + %18 = load i16, ptr %1, align 2 + %19 = sext i16 %18 to i32 + %20 = icmp eq i32 %19, 1 + store i1 %20, ptr %2, align 1 + %21 = load i1, ptr %2, align 1 br i1 %21, label %if.then.l6, label %if.end.l6 if.then.l6: ; preds = %foreach.loop.l4 - %idx1 = alloca i32, align 4 store i32 0, ptr %idx1, align 4 - %l = alloca i64, align 8 store i64 0, ptr %l, align 8 %22 = load [2 x i64], ptr @anonymous.0, align 8 %23 = load i32, ptr %idx1, align 4 @@ -94,7 +94,7 @@ foreach.inc.l4: ; preds = %if.end.l6 %idx3 = load i32, ptr %idx, align 4 %idx.inc4 = add i32 %idx3, 1 store i32 %idx.inc4, ptr %idx, align 4 - %32 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 %idx.inc4 + %32 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 %idx.inc4 %33 = load i16, ptr %32, align 2 store i16 %33, ptr %s, align 2 br label %foreach.cond.l4 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-continue/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-continue/ir-code.ll index 8f8b5bd74..a61d2e56e 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-continue/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-continue/ir-code.ll @@ -11,52 +11,52 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %s1 = alloca i16, align 2 - store i16 5, ptr %s1, align 2 - %0 = load i16, ptr %s1, align 2 - %1 = alloca [5 x i16], align 2 - %2 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 0 - store i16 1, ptr %2, align 2 - %3 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 1 - store i16 %0, ptr %3, align 2 - %4 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 2 - store i16 25, ptr %4, align 2 - %5 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 3 - store i16 -27, ptr %5, align 2 - %6 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 4 - store i16 -63, ptr %6, align 2 + %0 = alloca [5 x i16], align 2 %idx = alloca i32, align 4 - store i32 0, ptr %idx, align 4 %s = alloca i16, align 2 + %1 = alloca i16, align 2 + %2 = alloca i1, align 1 + %idx1 = alloca i32, align 4 + %l = alloca i64, align 8 + store i32 0, ptr %result, align 4 + store i16 5, ptr %s1, align 2 + %3 = load i16, ptr %s1, align 2 + %4 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 0 + store i16 1, ptr %4, align 2 + %5 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 1 + store i16 %3, ptr %5, align 2 + %6 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 2 + store i16 25, ptr %6, align 2 + %7 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 3 + store i16 -27, ptr %7, align 2 + %8 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 4 + store i16 -63, ptr %8, align 2 + store i32 0, ptr %idx, align 4 store i16 0, ptr %s, align 2 - %7 = load [5 x i16], ptr %1, align 2 - %8 = load i32, ptr %idx, align 4 - %9 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 %8 - %10 = load i16, ptr %9, align 2 - store i16 %10, ptr %s, align 2 + %9 = load [5 x i16], ptr %0, align 2 + %10 = load i32, ptr %idx, align 4 + %11 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 %10 + %12 = load i16, ptr %11, align 2 + store i16 %12, ptr %s, align 2 br label %foreach.loop.l4 foreach.loop.l4: ; preds = %foreach.cond.l4, %entry.l1 - %11 = load i16, ptr %s, align 2 - %12 = sext i16 %11 to i32 - %13 = call i32 (ptr, ...) @printf(ptr @0, i32 %12) - %14 = load i16, ptr %s, align 2 - %15 = and i16 %14, 1 - %16 = alloca i16, align 2 - store i16 %15, ptr %16, align 2 - %17 = load i16, ptr %16, align 2 - %18 = sext i16 %17 to i32 - %19 = icmp eq i32 %18, 1 - %20 = alloca i1, align 1 - store i1 %19, ptr %20, align 1 - %21 = load i1, ptr %20, align 1 + %13 = load i16, ptr %s, align 2 + %14 = sext i16 %13 to i32 + %15 = call i32 (ptr, ...) @printf(ptr @0, i32 %14) + %16 = load i16, ptr %s, align 2 + %17 = and i16 %16, 1 + store i16 %17, ptr %1, align 2 + %18 = load i16, ptr %1, align 2 + %19 = sext i16 %18 to i32 + %20 = icmp eq i32 %19, 1 + store i1 %20, ptr %2, align 1 + %21 = load i1, ptr %2, align 1 br i1 %21, label %if.then.l6, label %if.end.l6 if.then.l6: ; preds = %foreach.loop.l4 - %idx1 = alloca i32, align 4 store i32 0, ptr %idx1, align 4 - %l = alloca i64, align 8 store i64 0, ptr %l, align 8 %22 = load [2 x i64], ptr @anonymous.0, align 8 %23 = load i32, ptr %idx1, align 4 @@ -94,7 +94,7 @@ foreach.inc.l4: ; preds = %if.end.l6, %foreach %idx3 = load i32, ptr %idx, align 4 %idx.inc4 = add i32 %idx3, 1 store i32 %idx.inc4, ptr %idx, align 4 - %32 = getelementptr inbounds [5 x i16], ptr %1, i32 0, i32 %idx.inc4 + %32 = getelementptr inbounds [5 x i16], ptr %0, i32 0, i32 %idx.inc4 %33 = load i16, ptr %32, align 2 store i16 %33, ptr %s, align 2 br label %foreach.cond.l4 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-indexed-modified/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-indexed-modified/ir-code.ll index 81fb6d99b..143871e17 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-indexed-modified/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-indexed-modified/ir-code.ll @@ -9,27 +9,27 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %idx = alloca i32, align 4 - store i32 2, ptr %idx, align 4 %item = alloca i32, align 4 + %0 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 2, ptr %idx, align 4 store i32 0, ptr %item, align 4 - %0 = load [7 x i32], ptr @intArray, align 4 - %1 = load i32, ptr %idx, align 4 - %2 = getelementptr inbounds [7 x i32], ptr @intArray, i32 0, i32 %1 - %3 = load i32, ptr %2, align 4 - store i32 %3, ptr %item, align 4 + %1 = load [7 x i32], ptr @intArray, align 4 + %2 = load i32, ptr %idx, align 4 + %3 = getelementptr inbounds [7 x i32], ptr @intArray, i32 0, i32 %2 + %4 = load i32, ptr %3, align 4 + store i32 %4, ptr %item, align 4 br label %foreach.loop.l3 foreach.loop.l3: ; preds = %foreach.cond.l3, %entry.l1 - %4 = load i32, ptr %idx, align 4 - %5 = load i32, ptr %item, align 4 - %6 = call i32 (ptr, ...) @printf(ptr @0, i32 %4, i32 %5) - %7 = load i32, ptr %idx, align 4 - %8 = add i32 %7, 1 - store i32 %8, ptr %idx, align 4 - %9 = alloca i32, align 4 - store i32 %7, ptr %9, align 4 + %5 = load i32, ptr %idx, align 4 + %6 = load i32, ptr %item, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @0, i32 %5, i32 %6) + %8 = load i32, ptr %idx, align 4 + %9 = add i32 %8, 1 + store i32 %9, ptr %idx, align 4 + store i32 %8, ptr %0, align 4 br label %foreach.inc.l3 foreach.inc.l3: ; preds = %foreach.loop.l3 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-indexed/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-indexed/ir-code.ll index b02320b31..d3679b4c1 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-indexed/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-indexed/ir-code.ll @@ -9,10 +9,10 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %index = alloca i32, align 4 - store i32 0, ptr %index, align 4 %item = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 0, ptr %index, align 4 store i32 0, ptr %item, align 4 %0 = load [7 x i32], ptr @intArray, align 4 %1 = load i32, ptr %index, align 4 diff --git a/test/test-files/generator/foreach-loops/success-foreach-loop-normal/ir-code.ll b/test/test-files/generator/foreach-loops/success-foreach-loop-normal/ir-code.ll index 033226ebd..819d08f4c 100644 --- a/test/test-files/generator/foreach-loops/success-foreach-loop-normal/ir-code.ll +++ b/test/test-files/generator/foreach-loops/success-foreach-loop-normal/ir-code.ll @@ -9,10 +9,10 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %idx = alloca i32, align 4 - store i32 0, ptr %idx, align 4 %item = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i32 0, ptr %idx, align 4 store i32 0, ptr %item, align 4 %0 = load [7 x i32], ptr @intArray, align 4 %1 = load i32, ptr %idx, align 4 diff --git a/test/test-files/generator/functions/success-default-arg-value-expressions/ir-code.ll b/test/test-files/generator/functions/success-default-arg-value-expressions/ir-code.ll index 5d2c4292e..c202148c9 100644 --- a/test/test-files/generator/functions/success-default-arg-value-expressions/ir-code.ll +++ b/test/test-files/generator/functions/success-default-arg-value-expressions/ir-code.ll @@ -18,24 +18,24 @@ define internal double @_f__void__test() { entry.l5: %0 = call double @_f__void__getArg() %1 = alloca double, align 8 - store double %0, ptr %1, align 8 - %2 = load double, ptr %1, align 8 - %3 = fadd double %2, 1.200000e+00 - %4 = alloca double, align 8 - store double %3, ptr %4, align 8 + %2 = alloca double, align 8 %result = alloca double, align 8 - %5 = load double, ptr %4, align 8 + store double %0, ptr %1, align 8 + %3 = load double, ptr %1, align 8 + %4 = fadd double %3, 1.200000e+00 + store double %4, ptr %2, align 8 + %5 = load double, ptr %2, align 8 ret double %5 } define i32 @main() { entry.l9: %result = alloca i32, align 4 + %0 = alloca double, align 8 store i32 0, ptr %result, align 4 - %0 = call double @_f__void__test() - %1 = alloca double, align 8 - store double %0, ptr %1, align 8 - %2 = load double, ptr %1, align 8 + %1 = call double @_f__void__test() + store double %1, ptr %0, align 8 + %2 = load double, ptr %0, align 8 %3 = call i32 (ptr, ...) @printf(ptr @0, double %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/functions/success-default-arg-values/ir-code.ll b/test/test-files/generator/functions/success-default-arg-values/ir-code.ll index 63b8aeda8..4e9d280cd 100644 --- a/test/test-files/generator/functions/success-default-arg-values/ir-code.ll +++ b/test/test-files/generator/functions/success-default-arg-values/ir-code.ll @@ -9,15 +9,15 @@ target triple = "x86_64-w64-windows-gnu" define internal ptr @_f__void__getTestString__int_double_bool(i32 %0, double %1, i1 %2) { entry.l1: %arg0 = alloca i32, align 4 - store i32 %0, ptr %arg0, align 4 %arg1 = alloca double, align 8 - store double %1, ptr %arg1, align 8 %arg2 = alloca i1, align 1 - store i1 %2, ptr %arg2, align 1 %arg3 = alloca double, align 8 - store double 1.340000e+00, ptr %arg3, align 8 %result = alloca ptr, align 8 %arg31 = alloca ptr, align 8 + store i32 %0, ptr %arg0, align 4 + store double %1, ptr %arg1, align 8 + store i1 %2, ptr %arg2, align 1 + store double 1.340000e+00, ptr %arg3, align 8 store ptr @0, ptr %arg31, align 8 %3 = load ptr, ptr %arg31, align 8 ret ptr %3 @@ -26,20 +26,20 @@ entry.l1: define i32 @main() { entry.l5: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i32, align 4 + %1 = alloca double, align 8 + %2 = alloca i1, align 1 + %3 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 store i32 1, ptr %0, align 4 - %1 = load i32, ptr %0, align 4 - %2 = alloca double, align 8 - store double 3.400000e+00, ptr %2, align 8 - %3 = load double, ptr %2, align 8 - %4 = alloca i1, align 1 - store i1 true, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 - %6 = call ptr @_f__void__getTestString__int_double_bool(i32 %1, double %3, i1 %5) - %7 = alloca ptr, align 8 - store ptr %6, ptr %7, align 8 - %8 = load ptr, ptr %7, align 8 + %4 = load i32, ptr %0, align 4 + store double 3.400000e+00, ptr %1, align 8 + %5 = load double, ptr %1, align 8 + store i1 true, ptr %2, align 1 + %6 = load i1, ptr %2, align 1 + %7 = call ptr @_f__void__getTestString__int_double_bool(i32 %4, double %5, i1 %6) + store ptr %7, ptr %3, align 8 + %8 = load ptr, ptr %3, align 8 %9 = call i32 (ptr, ...) @printf(ptr @1, ptr %8) %10 = load i32, ptr %result, align 4 ret i32 %10 diff --git a/test/test-files/generator/functions/success-down-call/ir-code.ll b/test/test-files/generator/functions/success-down-call/ir-code.ll index 432ff2d66..1208a825b 100644 --- a/test/test-files/generator/functions/success-down-call/ir-code.ll +++ b/test/test-files/generator/functions/success-down-call/ir-code.ll @@ -8,11 +8,11 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 + %0 = alloca i32, align 4 store i32 0, ptr %result, align 4 - %0 = call i32 @_f__void__test() - %1 = alloca i32, align 4 - store i32 %0, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %1 = call i32 @_f__void__test() + store i32 %1, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/functions/success-explicit-inlining/ir-code.ll b/test/test-files/generator/functions/success-explicit-inlining/ir-code.ll index d53ca717d..fef69c7a3 100644 --- a/test/test-files/generator/functions/success-explicit-inlining/ir-code.ll +++ b/test/test-files/generator/functions/success-explicit-inlining/ir-code.ll @@ -18,11 +18,11 @@ entry.l1: define i32 @main() { entry.l5: %result = alloca i32, align 4 + %0 = alloca i64, align 8 store i32 0, ptr %result, align 4 - %0 = call i64 @_f__void__getInlinedValue() - %1 = alloca i64, align 8 - store i64 %0, ptr %1, align 8 - %2 = load i64, ptr %1, align 8 + %1 = call i64 @_f__void__getInlinedValue() + store i64 %1, ptr %0, align 8 + %2 = load i64, ptr %0, align 8 %3 = call i32 (ptr, ...) @printf(ptr @0, i64 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/functions/success-overloading/ir-code.ll b/test/test-files/generator/functions/success-overloading/ir-code.ll index 08ff211a0..096115f48 100644 --- a/test/test-files/generator/functions/success-overloading/ir-code.ll +++ b/test/test-files/generator/functions/success-overloading/ir-code.ll @@ -9,10 +9,10 @@ target triple = "x86_64-w64-windows-gnu" define internal i32 @_f__void__testFunc() { entry.l1: %result = alloca i32, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @0) - %1 = alloca i32, align 4 - store i32 1, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %0 = alloca i32, align 4 + %1 = call i32 (ptr, ...) @printf(ptr @0) + store i32 1, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 ret i32 %2 } @@ -21,11 +21,11 @@ declare i32 @printf(ptr, ...) define i32 @main() { entry.l11: %result = alloca i32, align 4 + %0 = alloca i32, align 4 store i32 0, ptr %result, align 4 - %0 = call i32 @_f__void__testFunc() - %1 = alloca i32, align 4 - store i32 %0, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %1 = call i32 @_f__void__testFunc() + store i32 %1, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 %3 = call i32 (ptr, ...) @printf(ptr @1, i32 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/functions/success-result-variable/ir-code.ll b/test/test-files/generator/functions/success-result-variable/ir-code.ll index 737eb3754..3c832ecdc 100644 --- a/test/test-files/generator/functions/success-result-variable/ir-code.ll +++ b/test/test-files/generator/functions/success-result-variable/ir-code.ll @@ -9,18 +9,19 @@ define internal i32 @_f__void__getAge() { entry.l1: %result = alloca i32, align 4 %i = alloca i1, align 1 + %0 = alloca i32, align 4 store i1 false, ptr %i, align 1 br i1 true, label %if.then.l3, label %if.else.l3 if.then.l3: ; preds = %entry.l1 store i32 20, ptr %result, align 4 - %0 = load i32, ptr %result, align 4 - ret i32 %0 + %1 = load i32, ptr %result, align 4 + ret i32 %1 if.else.l3: ; preds = %entry.l1 store i1 false, ptr %i, align 1 - %1 = load i1, ptr %i, align 1 - br i1 %1, label %if.then.l6, label %if.end.l6 + %2 = load i1, ptr %i, align 1 + br i1 %2, label %if.then.l6, label %if.end.l6 if.then.l6: ; preds = %if.else.l3 store i32 19, ptr %result, align 4 @@ -30,20 +31,19 @@ if.end.l6: ; preds = %if.then.l6, %if.els br label %if.end.l3 if.end.l3: ; preds = %if.end.l6 - %2 = alloca i32, align 4 - store i32 15, ptr %2, align 4 - %3 = load i32, ptr %2, align 4 + store i32 15, ptr %0, align 4 + %3 = load i32, ptr %0, align 4 ret i32 %3 } define i32 @main() { entry.l12: %result = alloca i32, align 4 + %0 = alloca i32, align 4 store i32 0, ptr %result, align 4 - %0 = call i32 @_f__void__getAge() - %1 = alloca i32, align 4 - store i32 %0, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %1 = call i32 @_f__void__getAge() + store i32 %1, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/generics/success-external-generic-functions/ir-code.ll b/test/test-files/generator/generics/success-external-generic-functions/ir-code.ll index bbdccb0be..97fe89b56 100644 --- a/test/test-files/generator/generics/success-external-generic-functions/ir-code.ll +++ b/test/test-files/generator/generics/success-external-generic-functions/ir-code.ll @@ -10,23 +10,23 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca double, align 8 + %1 = alloca i1, align 1 + %2 = alloca i32, align 4 + %3 = alloca i1, align 1 + %4 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store double 1.123000e+00, ptr %0, align 8 - %1 = load double, ptr %0, align 8 - call void @_p__void__printFormat__double(double %1) - %2 = alloca i1, align 1 - store i1 true, ptr %2, align 1 - %3 = alloca i32, align 4 - store i32 543, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 - call void @_p__void__printFormat__int(i32 %4) - %5 = alloca i1, align 1 - store i1 true, ptr %5, align 1 - %6 = load [2 x ptr], ptr @anonymous.0, align 8 - call void @_p__void__printFormat__stringarray([2 x ptr] %6) - %7 = alloca i1, align 1 - store i1 true, ptr %7, align 1 + %5 = load double, ptr %0, align 8 + call void @_p__void__printFormat__double(double %5) + store i1 true, ptr %1, align 1 + store i32 543, ptr %2, align 4 + %6 = load i32, ptr %2, align 4 + call void @_p__void__printFormat__int(i32 %6) + store i1 true, ptr %3, align 1 + %7 = load [2 x ptr], ptr @anonymous.0, align 8 + call void @_p__void__printFormat__stringarray([2 x ptr] %7) + store i1 true, ptr %4, align 1 %8 = load i32, ptr %result, align 4 ret i32 %8 } diff --git a/test/test-files/generator/generics/success-generic-functions/ir-code.ll b/test/test-files/generator/generics/success-generic-functions/ir-code.ll index 72e7f8fc4..49103f5b3 100644 --- a/test/test-files/generator/generics/success-generic-functions/ir-code.ll +++ b/test/test-files/generator/generics/success-generic-functions/ir-code.ll @@ -9,72 +9,72 @@ target triple = "x86_64-w64-windows-gnu" define internal double @_f__void__genericFunction__int_double(i32 %0, double %1) { entry.l4: %arg1 = alloca i32, align 4 - store i32 %0, ptr %arg1, align 4 %arg2 = alloca double, align 8 - store double %1, ptr %arg2, align 8 %arg3 = alloca i32, align 4 - store i32 10, ptr %arg3, align 4 %result = alloca double, align 8 - %2 = load i32, ptr %arg1, align 4 - %3 = load double, ptr %arg2, align 8 - %4 = sitofp i32 %2 to double - %5 = fadd double %4, %3 - %6 = load i32, ptr %arg3, align 4 - %7 = sitofp i32 %6 to double - %8 = fadd double %5, %7 - %9 = alloca double, align 8 - store double %8, ptr %9, align 8 - %10 = load double, ptr %9, align 8 + %2 = alloca double, align 8 + store i32 %0, ptr %arg1, align 4 + store double %1, ptr %arg2, align 8 + store i32 10, ptr %arg3, align 4 + %3 = load i32, ptr %arg1, align 4 + %4 = load double, ptr %arg2, align 8 + %5 = sitofp i32 %3 to double + %6 = fadd double %5, %4 + %7 = load i32, ptr %arg3, align 4 + %8 = sitofp i32 %7 to double + %9 = fadd double %6, %8 + store double %9, ptr %2, align 8 + %10 = load double, ptr %2, align 8 ret double %10 } define internal double @_f__void__genericFunction__long_double(i64 %0, double %1) { entry.l4: %arg1 = alloca i64, align 8 - store i64 %0, ptr %arg1, align 8 %arg2 = alloca double, align 8 - store double %1, ptr %arg2, align 8 %arg3 = alloca i32, align 4 - store i32 10, ptr %arg3, align 4 %result = alloca double, align 8 - %2 = load i64, ptr %arg1, align 8 - %3 = load double, ptr %arg2, align 8 - %4 = sitofp i64 %2 to double - %5 = fadd double %4, %3 - %6 = load i32, ptr %arg3, align 4 - %7 = sitofp i32 %6 to double - %8 = fadd double %5, %7 - %9 = alloca double, align 8 - store double %8, ptr %9, align 8 - %10 = load double, ptr %9, align 8 + %2 = alloca double, align 8 + store i64 %0, ptr %arg1, align 8 + store double %1, ptr %arg2, align 8 + store i32 10, ptr %arg3, align 4 + %3 = load i64, ptr %arg1, align 8 + %4 = load double, ptr %arg2, align 8 + %5 = sitofp i64 %3 to double + %6 = fadd double %5, %4 + %7 = load i32, ptr %arg3, align 4 + %8 = sitofp i32 %7 to double + %9 = fadd double %6, %8 + store double %9, ptr %2, align 8 + %10 = load double, ptr %2, align 8 ret double %10 } define i32 @main() { entry.l12: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i32, align 4 - store i32 1, ptr %0, align 4 - %1 = load i32, ptr %0, align 4 + %1 = alloca double, align 8 %2 = alloca double, align 8 - store double 2.400000e+00, ptr %2, align 8 - %3 = load double, ptr %2, align 8 - %4 = call double @_f__void__genericFunction__int_double(i32 %1, double %3) + %3 = alloca i64, align 8 + %4 = alloca double, align 8 %5 = alloca double, align 8 - store double %4, ptr %5, align 8 - %6 = load double, ptr %5, align 8 - %7 = call i32 (ptr, ...) @printf(ptr @0, double %6) - %8 = alloca i64, align 8 - store i64 12, ptr %8, align 8 - %9 = load i64, ptr %8, align 8 - %10 = alloca double, align 8 - store double 2.000000e+00, ptr %10, align 8 - %11 = load double, ptr %10, align 8 - %12 = call double @_f__void__genericFunction__long_double(i64 %9, double %11) - %13 = alloca double, align 8 - store double %12, ptr %13, align 8 - %14 = load double, ptr %13, align 8 + store i32 0, ptr %result, align 4 + store i32 1, ptr %0, align 4 + %6 = load i32, ptr %0, align 4 + store double 2.400000e+00, ptr %1, align 8 + %7 = load double, ptr %1, align 8 + %8 = call double @_f__void__genericFunction__int_double(i32 %6, double %7) + store double %8, ptr %2, align 8 + %9 = load double, ptr %2, align 8 + %10 = call i32 (ptr, ...) @printf(ptr @0, double %9) + store i64 12, ptr %3, align 8 + %11 = load i64, ptr %3, align 8 + store double 2.000000e+00, ptr %4, align 8 + %12 = load double, ptr %4, align 8 + %13 = call double @_f__void__genericFunction__long_double(i64 %11, double %12) + store double %13, ptr %5, align 8 + %14 = load double, ptr %5, align 8 %15 = call i32 (ptr, ...) @printf(ptr @1, double %14) %16 = load i32, ptr %result, align 4 ret i32 %16 diff --git a/test/test-files/generator/generics/success-generic-functions2/ir-code.ll b/test/test-files/generator/generics/success-generic-functions2/ir-code.ll index 97804dde5..6f1c58678 100644 --- a/test/test-files/generator/generics/success-generic-functions2/ir-code.ll +++ b/test/test-files/generator/generics/success-generic-functions2/ir-code.ll @@ -11,41 +11,41 @@ target triple = "x86_64-w64-windows-gnu" define internal i32 @_f__void__sumNumbers__longarray_int(ptr %0, i32 %1) { entry.l4: %numberArray = alloca ptr, align 8 - store ptr %0, ptr %numberArray, align 8 %arrayLength = alloca i32, align 4 - store i32 %1, ptr %arrayLength, align 4 %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 + %2 = alloca i32, align 4 + %3 = alloca i1, align 1 + store ptr %0, ptr %numberArray, align 8 + store i32 %1, ptr %arrayLength, align 4 + store i32 0, ptr %result, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l6 for.l6: ; preds = %for.cond.l6 - %2 = load i32, ptr %i, align 4 - %3 = load ptr, ptr %numberArray, align 8 - %4 = getelementptr inbounds i64, ptr %3, i32 %2 - %5 = load i64, ptr %4, align 8 - %6 = load i32, ptr %result, align 4 - %7 = trunc i64 %5 to i32 - %8 = add i32 %6, %7 - store i32 %8, ptr %result, align 4 + %4 = load i32, ptr %i, align 4 + %5 = load ptr, ptr %numberArray, align 8 + %6 = getelementptr inbounds i64, ptr %5, i32 %4 + %7 = load i64, ptr %6, align 8 + %8 = load i32, ptr %result, align 4 + %9 = trunc i64 %7 to i32 + %10 = add i32 %8, %9 + store i32 %10, ptr %result, align 4 br label %for.inc.l6 for.inc.l6: ; preds = %for.l6 - %9 = load i32, ptr %i, align 4 - %10 = add i32 %9, 1 - store i32 %10, ptr %i, align 4 - %11 = alloca i32, align 4 - store i32 %9, ptr %11, align 4 + %11 = load i32, ptr %i, align 4 + %12 = add i32 %11, 1 + store i32 %12, ptr %i, align 4 + store i32 %11, ptr %2, align 4 br label %for.cond.l6 for.cond.l6: ; preds = %for.inc.l6, %entry.l4 - %12 = load i32, ptr %i, align 4 - %13 = load i32, ptr %arrayLength, align 4 - %14 = icmp slt i32 %12, %13 - %15 = alloca i1, align 1 - store i1 %14, ptr %15, align 1 - %16 = load i1, ptr %15, align 1 + %13 = load i32, ptr %i, align 4 + %14 = load i32, ptr %arrayLength, align 4 + %15 = icmp slt i32 %13, %14 + store i1 %15, ptr %3, align 1 + %16 = load i1, ptr %3, align 1 br i1 %16, label %for.l6, label %for.end.l6 for.end.l6: ; preds = %for.cond.l6 @@ -56,41 +56,41 @@ for.end.l6: ; preds = %for.cond.l6 define internal i32 @_f__void__sumNumbers__shortarray_int(ptr %0, i32 %1) { entry.l4: %numberArray = alloca ptr, align 8 - store ptr %0, ptr %numberArray, align 8 %arrayLength = alloca i32, align 4 - store i32 %1, ptr %arrayLength, align 4 %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 + %2 = alloca i32, align 4 + %3 = alloca i1, align 1 + store ptr %0, ptr %numberArray, align 8 + store i32 %1, ptr %arrayLength, align 4 + store i32 0, ptr %result, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l6 for.l6: ; preds = %for.cond.l6 - %2 = load i32, ptr %i, align 4 - %3 = load ptr, ptr %numberArray, align 8 - %4 = getelementptr inbounds i16, ptr %3, i32 %2 - %5 = load i16, ptr %4, align 2 - %6 = load i32, ptr %result, align 4 - %7 = sext i16 %5 to i32 - %8 = add i32 %6, %7 - store i32 %8, ptr %result, align 4 + %4 = load i32, ptr %i, align 4 + %5 = load ptr, ptr %numberArray, align 8 + %6 = getelementptr inbounds i16, ptr %5, i32 %4 + %7 = load i16, ptr %6, align 2 + %8 = load i32, ptr %result, align 4 + %9 = sext i16 %7 to i32 + %10 = add i32 %8, %9 + store i32 %10, ptr %result, align 4 br label %for.inc.l6 for.inc.l6: ; preds = %for.l6 - %9 = load i32, ptr %i, align 4 - %10 = add i32 %9, 1 - store i32 %10, ptr %i, align 4 - %11 = alloca i32, align 4 - store i32 %9, ptr %11, align 4 + %11 = load i32, ptr %i, align 4 + %12 = add i32 %11, 1 + store i32 %12, ptr %i, align 4 + store i32 %11, ptr %2, align 4 br label %for.cond.l6 for.cond.l6: ; preds = %for.inc.l6, %entry.l4 - %12 = load i32, ptr %i, align 4 - %13 = load i32, ptr %arrayLength, align 4 - %14 = icmp slt i32 %12, %13 - %15 = alloca i1, align 1 - store i1 %14, ptr %15, align 1 - %16 = load i1, ptr %15, align 1 + %13 = load i32, ptr %i, align 4 + %14 = load i32, ptr %arrayLength, align 4 + %15 = icmp slt i32 %13, %14 + store i1 %15, ptr %3, align 1 + %16 = load i1, ptr %3, align 1 br i1 %16, label %for.l6, label %for.end.l6 for.end.l6: ; preds = %for.cond.l6 @@ -101,35 +101,35 @@ for.end.l6: ; preds = %for.cond.l6 define internal void @_p__void__printData__int_intarray(i32 %0, [2 x i32] %1) { entry.l11: %arrayLength = alloca i32, align 4 - store i32 %0, ptr %arrayLength, align 4 %list = alloca [2 x i32], align 4 - store [2 x i32] %1, ptr %list, align 4 %i = alloca i32, align 4 + %2 = alloca i32, align 4 + %3 = alloca i1, align 1 + store i32 %0, ptr %arrayLength, align 4 + store [2 x i32] %1, ptr %list, align 4 store i32 0, ptr %i, align 4 br label %for.cond.l12 for.l12: ; preds = %for.cond.l12 - %2 = load i32, ptr %i, align 4 - %3 = getelementptr inbounds [2 x i32], ptr %list, i32 0, i32 %2 - %4 = load i32, ptr %3, align 4 - %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) + %4 = load i32, ptr %i, align 4 + %5 = getelementptr inbounds [2 x i32], ptr %list, i32 0, i32 %4 + %6 = load i32, ptr %5, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @0, i32 %6) br label %for.inc.l12 for.inc.l12: ; preds = %for.l12 - %6 = load i32, ptr %i, align 4 - %7 = add i32 %6, 1 - store i32 %7, ptr %i, align 4 - %8 = alloca i32, align 4 - store i32 %6, ptr %8, align 4 + %8 = load i32, ptr %i, align 4 + %9 = add i32 %8, 1 + store i32 %9, ptr %i, align 4 + store i32 %8, ptr %2, align 4 br label %for.cond.l12 for.cond.l12: ; preds = %for.inc.l12, %entry.l11 - %9 = load i32, ptr %i, align 4 - %10 = load i32, ptr %arrayLength, align 4 - %11 = icmp slt i32 %9, %10 - %12 = alloca i1, align 1 - store i1 %11, ptr %12, align 1 - %13 = load i1, ptr %12, align 1 + %10 = load i32, ptr %i, align 4 + %11 = load i32, ptr %arrayLength, align 4 + %12 = icmp slt i32 %10, %11 + store i1 %12, ptr %3, align 1 + %13 = load i1, ptr %3, align 1 br i1 %13, label %for.l12, label %for.end.l12 for.end.l12: ; preds = %for.cond.l12 @@ -141,38 +141,38 @@ declare i32 @printf(ptr, ...) define i32 @main() { entry.l17: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = load [7 x i16], ptr @numberList1, align 2 + %0 = alloca i32, align 4 %1 = alloca i32, align 4 - store i32 7, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 - %3 = call i32 @_f__void__sumNumbers__shortarray_int(ptr @numberList1, i32 %2) - %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 - %5 = load [4 x i64], ptr @numberList2, align 8 - %6 = alloca i32, align 4 - store i32 4, ptr %6, align 4 - %7 = load i32, ptr %6, align 4 - %8 = call i32 @_f__void__sumNumbers__longarray_int(ptr @numberList2, i32 %7) - %9 = alloca i32, align 4 - store i32 %8, ptr %9, align 4 - %10 = load i32, ptr %4, align 4 - %11 = load i32, ptr %9, align 4 - %12 = alloca [2 x i32], align 4 - %13 = getelementptr inbounds [2 x i32], ptr %12, i32 0, i32 0 - store i32 %10, ptr %13, align 4 - %14 = getelementptr inbounds [2 x i32], ptr %12, i32 0, i32 1 - store i32 %11, ptr %14, align 4 - %15 = load [2 x i32], ptr %12, align 4 - %16 = alloca i32, align 4 - store i32 2, ptr %16, align 4 - %17 = load i32, ptr %16, align 4 - %18 = load [2 x i32], ptr %12, align 4 - call void @_p__void__printData__int_intarray(i32 %17, [2 x i32] %18) - %19 = alloca i1, align 1 - store i1 true, ptr %19, align 1 - %20 = load i32, ptr %4, align 4 - %21 = load i32, ptr %9, align 4 + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 + %4 = alloca [2 x i32], align 4 + %5 = alloca i32, align 4 + %6 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %7 = load [7 x i16], ptr @numberList1, align 2 + store i32 7, ptr %0, align 4 + %8 = load i32, ptr %0, align 4 + %9 = call i32 @_f__void__sumNumbers__shortarray_int(ptr @numberList1, i32 %8) + store i32 %9, ptr %1, align 4 + %10 = load [4 x i64], ptr @numberList2, align 8 + store i32 4, ptr %2, align 4 + %11 = load i32, ptr %2, align 4 + %12 = call i32 @_f__void__sumNumbers__longarray_int(ptr @numberList2, i32 %11) + store i32 %12, ptr %3, align 4 + %13 = load i32, ptr %1, align 4 + %14 = load i32, ptr %3, align 4 + %15 = getelementptr inbounds [2 x i32], ptr %4, i32 0, i32 0 + store i32 %13, ptr %15, align 4 + %16 = getelementptr inbounds [2 x i32], ptr %4, i32 0, i32 1 + store i32 %14, ptr %16, align 4 + %17 = load [2 x i32], ptr %4, align 4 + store i32 2, ptr %5, align 4 + %18 = load i32, ptr %5, align 4 + %19 = load [2 x i32], ptr %4, align 4 + call void @_p__void__printData__int_intarray(i32 %18, [2 x i32] %19) + store i1 true, ptr %6, align 1 + %20 = load i32, ptr %1, align 4 + %21 = load i32, ptr %3, align 4 %22 = call i32 (ptr, ...) @printf(ptr @1, i32 %20, i32 %21) %23 = load i32, ptr %result, align 4 ret i32 %23 diff --git a/test/test-files/generator/generics/success-generic-structs/ir-code.ll b/test/test-files/generator/generics/success-generic-structs/ir-code.ll index 684fcb166..dbb2aeee8 100644 --- a/test/test-files/generator/generics/success-generic-structs/ir-code.ll +++ b/test/test-files/generator/generics/success-generic-structs/ir-code.ll @@ -10,11 +10,11 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l8: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %dbl = alloca double, align 8 - store double 3.467000e+00, ptr %dbl, align 8 %0 = alloca %_s__double__Vector__doubleptr_int, align 8 %1 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + store double 3.467000e+00, ptr %dbl, align 8 store ptr %dbl, ptr %1, align 8 %2 = load ptr, ptr %1, align 8 %3 = getelementptr inbounds %_s__double__Vector__doubleptr_int, ptr %0, i32 0, i32 0 diff --git a/test/test-files/generator/if-stmts/success-if-else-stmt/ir-code.ll b/test/test-files/generator/if-stmts/success-if-else-stmt/ir-code.ll index 8e1e0fbc2..033c185ce 100644 --- a/test/test-files/generator/if-stmts/success-if-else-stmt/ir-code.ll +++ b/test/test-files/generator/if-stmts/success-if-else-stmt/ir-code.ll @@ -11,30 +11,30 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i1, align 1 + %1 = alloca i1, align 1 + %2 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i1 false, ptr %0, align 1 - %1 = load i1, ptr %0, align 1 - br i1 %1, label %if.then.l2, label %if.else.l2 + %3 = load i1, ptr %0, align 1 + br i1 %3, label %if.then.l2, label %if.else.l2 if.then.l2: ; preds = %entry.l1 - %2 = call i32 (ptr, ...) @printf(ptr @0) + %4 = call i32 (ptr, ...) @printf(ptr @0) br label %if.end.l2 if.else.l2: ; preds = %entry.l1 - %3 = alloca i1, align 1 - store i1 false, ptr %3, align 1 - %4 = load i1, ptr %3, align 1 - br i1 %4, label %if.then.l4, label %if.else.l4 + store i1 false, ptr %1, align 1 + %5 = load i1, ptr %1, align 1 + br i1 %5, label %if.then.l4, label %if.else.l4 if.then.l4: ; preds = %if.else.l2 - %5 = call i32 (ptr, ...) @printf(ptr @1) + %6 = call i32 (ptr, ...) @printf(ptr @1) br label %if.end.l4 if.else.l4: ; preds = %if.else.l2 - %6 = alloca i1, align 1 - store i1 false, ptr %6, align 1 - %7 = load i1, ptr %6, align 1 + store i1 false, ptr %2, align 1 + %7 = load i1, ptr %2, align 1 br i1 %7, label %if.then.l6, label %if.else.l6 if.then.l6: ; preds = %if.else.l4 diff --git a/test/test-files/generator/if-stmts/success-if-stmt/ir-code.ll b/test/test-files/generator/if-stmts/success-if-stmt/ir-code.ll index f70ecf65d..378af45c6 100644 --- a/test/test-files/generator/if-stmts/success-if-stmt/ir-code.ll +++ b/test/test-files/generator/if-stmts/success-if-stmt/ir-code.ll @@ -9,17 +9,17 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i1, align 1 + %1 = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i1 true, ptr %0, align 1 - %1 = load i1, ptr %0, align 1 - br i1 %1, label %if.then.l3, label %if.end.l3 + %2 = load i1, ptr %0, align 1 + br i1 %2, label %if.then.l3, label %if.end.l3 if.then.l3: ; preds = %entry.l1 - %2 = call i32 (ptr, ...) @printf(ptr @0) - %3 = alloca i32, align 4 - store i32 0, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 + %3 = call i32 (ptr, ...) @printf(ptr @0) + store i32 0, ptr %1, align 4 + %4 = load i32, ptr %1, align 4 ret i32 %4 if.end.l3: ; preds = %entry.l1 diff --git a/test/test-files/generator/imports/success-modules-std/ir-code.ll b/test/test-files/generator/imports/success-modules-std/ir-code.ll index 53b2a8342..04dd024d2 100644 --- a/test/test-files/generator/imports/success-modules-std/ir-code.ll +++ b/test/test-files/generator/imports/success-modules-std/ir-code.ll @@ -8,14 +8,14 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i1, align 1 + %1 = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i1 true, ptr %0, align 1 - %1 = load i1, ptr %0, align 1 - %2 = call i32 @_f__void__toInt__bool(i1 %1) - %3 = alloca i32, align 4 - store i32 %2, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 + %2 = load i1, ptr %0, align 1 + %3 = call i32 @_f__void__toInt__bool(i1 %2) + store i32 %3, ptr %1, align 4 + %4 = load i32, ptr %1, align 4 %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) %6 = load i32, ptr %result, align 4 ret i32 %6 diff --git a/test/test-files/generator/imports/success-modules/ir-code.ll b/test/test-files/generator/imports/success-modules/ir-code.ll index 1a4a9bb2d..d702f402e 100644 --- a/test/test-files/generator/imports/success-modules/ir-code.ll +++ b/test/test-files/generator/imports/success-modules/ir-code.ll @@ -8,11 +8,11 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 + %0 = alloca i32, align 4 store i32 0, ptr %result, align 4 - %0 = call i32 @_f__void__forwardToOtherModule() - %1 = alloca i32, align 4 - store i32 %0, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 + %1 = call i32 @_f__void__forwardToOtherModule() + store i32 %1, ptr %0, align 4 + %2 = load i32, ptr %0, align 4 %3 = call i32 (ptr, ...) @printf(ptr @0, i32 %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/methods/success-method-down-up-call/ir-code.ll b/test/test-files/generator/methods/success-method-down-up-call/ir-code.ll index 288a52cfd..58ecdd1e2 100644 --- a/test/test-files/generator/methods/success-method-down-up-call/ir-code.ll +++ b/test/test-files/generator/methods/success-method-down-up-call/ir-code.ll @@ -10,15 +10,15 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__char__TestStruct__char_int, align 8 - %1 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %0, i32 0, i32 0 - store i8 97, ptr %1, align 1 - %2 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %0, i32 0, i32 1 - store i32 1, ptr %2, align 4 + %1 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %2 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %0, i32 0, i32 0 + store i8 97, ptr %2, align 1 + %3 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %0, i32 0, i32 1 + store i32 1, ptr %3, align 4 call void @_mp__TestStruct_char__printTest(ptr %0) - %3 = alloca i1, align 1 - store i1 true, ptr %3, align 1 + store i1 true, ptr %1, align 1 %4 = load i32, ptr %result, align 4 ret i32 %4 } @@ -26,12 +26,12 @@ entry.l1: define internal void @_mp__TestStruct_char__printTest(ptr %0) { entry.l13: %this = alloca ptr, align 8 + %1 = alloca i32, align 4 store ptr %0, ptr %this, align 8 - %1 = load ptr, ptr %this, align 8 - %2 = call i32 @_mf__TestStruct_char__getTest(ptr %1) - %3 = alloca i32, align 4 - store i32 %2, ptr %3, align 4 - %4 = load i32, ptr %3, align 4 + %2 = load ptr, ptr %this, align 8 + %3 = call i32 @_mf__TestStruct_char__getTest(ptr %2) + store i32 %3, ptr %1, align 4 + %4 = load i32, ptr %1, align 4 %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) ret void } @@ -41,29 +41,29 @@ declare i32 @printf(ptr, ...) define internal i32 @_mf__TestStruct_char__getTest(ptr %0) { entry.l17: %this = alloca ptr, align 8 - store ptr %0, ptr %this, align 8 %result = alloca i32, align 4 - %1 = load ptr, ptr %this, align 8 - %2 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %1, i32 0, i32 1 - %3 = load i32, ptr %2, align 4 - %4 = icmp eq i32 %3, 1 - %5 = alloca i1, align 1 - store i1 %4, ptr %5, align 1 - %6 = load i1, ptr %5, align 1 - br i1 %6, label %if.then.l18, label %if.end.l18 + %1 = alloca i1, align 1 + %2 = alloca i32, align 4 + %3 = alloca i1, align 1 + store ptr %0, ptr %this, align 8 + %4 = load ptr, ptr %this, align 8 + %5 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %4, i32 0, i32 1 + %6 = load i32, ptr %5, align 4 + %7 = icmp eq i32 %6, 1 + store i1 %7, ptr %1, align 1 + %8 = load i1, ptr %1, align 1 + br i1 %8, label %if.then.l18, label %if.end.l18 if.then.l18: ; preds = %entry.l17 - %7 = load ptr, ptr %this, align 8 - %8 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %7, i32 0, i32 1 - %9 = load i32, ptr %8, align 4 - %10 = add i32 %9, 1 - store i32 %10, ptr %8, align 4 - %11 = alloca i32, align 4 - store i32 %9, ptr %11, align 4 - %12 = load ptr, ptr %this, align 8 - call void @_mp__TestStruct_char__printTest(ptr %12) - %13 = alloca i1, align 1 - store i1 true, ptr %13, align 1 + %9 = load ptr, ptr %this, align 8 + %10 = getelementptr inbounds %_s__char__TestStruct__char_int, ptr %9, i32 0, i32 1 + %11 = load i32, ptr %10, align 4 + %12 = add i32 %11, 1 + store i32 %12, ptr %10, align 4 + store i32 %11, ptr %2, align 4 + %13 = load ptr, ptr %this, align 8 + call void @_mp__TestStruct_char__printTest(ptr %13) + store i1 true, ptr %3, align 1 br label %if.end.l18 if.end.l18: ; preds = %if.then.l18, %entry.l17 diff --git a/test/test-files/generator/methods/success-methods/ir-code.ll b/test/test-files/generator/methods/success-methods/ir-code.ll index 63d1b68cf..6741b0251 100644 --- a/test/test-files/generator/methods/success-methods/ir-code.ll +++ b/test/test-files/generator/methods/success-methods/ir-code.ll @@ -12,8 +12,8 @@ target triple = "x86_64-w64-windows-gnu" define internal ptr @_mf__Letter__getContent(ptr %0) { entry.l5: %this = alloca ptr, align 8 - store ptr %0, ptr %this, align 8 %result = alloca ptr, align 8 + store ptr %0, ptr %this, align 8 %1 = load ptr, ptr %this, align 8 %2 = getelementptr inbounds %_s__Letter__string, ptr %1, i32 0, i32 0 %3 = load ptr, ptr %2, align 8 @@ -23,8 +23,8 @@ entry.l5: define internal void @_mp__Letter__setContent__string(ptr %0, ptr %1) { entry.l9: %this = alloca ptr, align 8 - store ptr %0, ptr %this, align 8 %text = alloca ptr, align 8 + store ptr %0, ptr %this, align 8 store ptr %1, ptr %text, align 8 %2 = load ptr, ptr %text, align 8 %3 = load ptr, ptr %this, align 8 @@ -36,20 +36,20 @@ entry.l9: define i32 @main() { entry.l13: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__Letter__string, align 8 - %1 = getelementptr inbounds %_s__Letter__string, ptr %0, i32 0, i32 0 - store ptr @0, ptr %1, align 8 - %2 = alloca ptr, align 8 - store ptr @1, ptr %2, align 8 - %3 = load ptr, ptr %2, align 8 - call void @_mp__Letter__setContent__string(ptr %0, ptr %3) - %4 = alloca i1, align 1 - store i1 true, ptr %4, align 1 - %5 = call ptr @_mf__Letter__getContent(ptr %0) - %6 = alloca ptr, align 8 - store ptr %5, ptr %6, align 8 - %7 = load ptr, ptr %6, align 8 + %1 = alloca ptr, align 8 + %2 = alloca i1, align 1 + %3 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + %4 = getelementptr inbounds %_s__Letter__string, ptr %0, i32 0, i32 0 + store ptr @0, ptr %4, align 8 + store ptr @1, ptr %1, align 8 + %5 = load ptr, ptr %1, align 8 + call void @_mp__Letter__setContent__string(ptr %0, ptr %5) + store i1 true, ptr %2, align 1 + %6 = call ptr @_mf__Letter__getContent(ptr %0) + store ptr %6, ptr %3, align 8 + %7 = load ptr, ptr %3, align 8 %8 = call i32 (ptr, ...) @printf(ptr @2, ptr %7) %9 = load i32, ptr %result, align 4 ret i32 %9 diff --git a/test/test-files/generator/operators/success-operators/ir-code.ll b/test/test-files/generator/operators/success-operators/ir-code.ll index 6073994fc..4f006ed71 100644 --- a/test/test-files/generator/operators/success-operators/ir-code.ll +++ b/test/test-files/generator/operators/success-operators/ir-code.ll @@ -8,37 +8,51 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %val = alloca i32, align 4 - store i32 1, ptr %val, align 4 %val1 = alloca i32, align 4 - store i32 1, ptr %val1, align 4 - %0 = load i32, ptr %val1, align 4 - %1 = add i32 %0, 1 - store i32 %1, ptr %val1, align 4 + %0 = alloca i32, align 4 + %1 = alloca i32, align 4 + %val2 = alloca i32, align 4 %2 = alloca i32, align 4 - store i32 %0, ptr %2, align 4 - %3 = load i32, ptr %2, align 4 - %4 = sub i32 %3, 1 - store i32 %4, ptr %2, align 4 + %3 = alloca i32, align 4 + %val3 = alloca i32, align 4 + %4 = alloca i32, align 4 %5 = alloca i32, align 4 - store i32 %3, ptr %5, align 4 - %6 = load i32, ptr %5, align 4 - %7 = mul i32 %6, 2 - %8 = alloca i32, align 4 - store i32 %7, ptr %8, align 4 - %9 = load i32, ptr %8, align 4 - %10 = shl i32 %9, 2 - %11 = alloca i32, align 4 - store i32 %10, ptr %11, align 4 - %12 = load i32, ptr %11, align 4 - %13 = load i32, ptr %val, align 4 - %14 = add i32 %13, %12 - store i32 %14, ptr %val, align 4 - %15 = load i32, ptr %val, align 4 - %16 = call i32 (ptr, ...) @printf(ptr @0, i32 %15) - %17 = load i32, ptr %result, align 4 - ret i32 %17 + store i32 0, ptr %result, align 4 + store i32 1, ptr %val, align 4 + store i32 1, ptr %val1, align 4 + %6 = load i32, ptr %val1, align 4 + %7 = add i32 %6, 1 + store i32 %7, ptr %val1, align 4 + store i32 %6, ptr %0, align 4 + %8 = load i32, ptr %0, align 4 + %9 = sub i32 %8, 1 + store i32 %9, ptr %0, align 4 + store i32 %8, ptr %1, align 4 + %10 = load i32, ptr %1, align 4 + store i32 1, ptr %val2, align 4 + %11 = load i32, ptr %val2, align 4 + %12 = add i32 %11, 1 + store i32 %12, ptr %val2, align 4 + store i32 %11, ptr %2, align 4 + %13 = load i32, ptr %2, align 4 + %14 = sub i32 %13, 1 + store i32 %14, ptr %2, align 4 + store i32 %13, ptr %3, align 4 + store i32 2, ptr %val3, align 4 + %15 = mul i32 %10, 2 + store i32 %15, ptr %4, align 4 + %16 = load i32, ptr %4, align 4 + %17 = shl i32 %16, 2 + store i32 %17, ptr %5, align 4 + %18 = load i32, ptr %5, align 4 + %19 = load i32, ptr %val, align 4 + %20 = add i32 %19, %18 + store i32 %20, ptr %val, align 4 + %21 = load i32, ptr %val, align 4 + %22 = call i32 (ptr, ...) @printf(ptr @0, i32 %21) + %23 = load i32, ptr %result, align 4 + ret i32 %23 } declare i32 @printf(ptr, ...) diff --git a/test/test-files/generator/operators/success-operators2/ir-code.ll b/test/test-files/generator/operators/success-operators2/ir-code.ll index 13ff7b58b..8212d3bbf 100644 --- a/test/test-files/generator/operators/success-operators2/ir-code.ll +++ b/test/test-files/generator/operators/success-operators2/ir-code.ll @@ -9,8 +9,8 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 + store i32 0, ptr %result, align 4 store i32 1, ptr %i, align 4 %0 = load i32, ptr %i, align 4 %1 = add i32 %0, 2 diff --git a/test/test-files/generator/operators/success-short-circuiting/ir-code.ll b/test/test-files/generator/operators/success-short-circuiting/ir-code.ll index dcf2deef3..54d01c50e 100644 --- a/test/test-files/generator/operators/success-short-circuiting/ir-code.ll +++ b/test/test-files/generator/operators/success-short-circuiting/ir-code.ll @@ -11,10 +11,10 @@ target triple = "x86_64-w64-windows-gnu" define internal i1 @_f__void__functionTrue() { entry.l1: %result = alloca i1, align 1 - %0 = call i32 (ptr, ...) @printf(ptr @0) - %1 = alloca i1, align 1 - store i1 true, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 + %0 = alloca i1, align 1 + %1 = call i32 (ptr, ...) @printf(ptr @0) + store i1 true, ptr %0, align 1 + %2 = load i1, ptr %0, align 1 ret i1 %2 } @@ -23,55 +23,55 @@ declare i32 @printf(ptr, ...) define internal i1 @_f__void__functionFalse() { entry.l6: %result = alloca i1, align 1 - %0 = call i32 (ptr, ...) @printf(ptr @1) - %1 = alloca i1, align 1 - store i1 false, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 + %0 = alloca i1, align 1 + %1 = call i32 (ptr, ...) @printf(ptr @1) + store i1 false, ptr %0, align 1 + %2 = load i1, ptr %0, align 1 ret i1 %2 } define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i1 @_f__void__functionFalse() + %0 = alloca i1, align 1 %1 = alloca i1, align 1 - store i1 %0, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 - br i1 %2, label %land.1.l13, label %land.end.l13 + %2 = alloca i1, align 1 + %3 = alloca i1, align 1 + %4 = alloca i1, align 1 + %5 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %6 = call i1 @_f__void__functionFalse() + store i1 %6, ptr %0, align 1 + %7 = load i1, ptr %0, align 1 + br i1 %7, label %land.1.l13, label %land.end.l13 land.1.l13: ; preds = %entry.l11 - %3 = call i1 @_f__void__functionTrue() - %4 = alloca i1, align 1 - store i1 %3, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 + %8 = call i1 @_f__void__functionTrue() + store i1 %8, ptr %1, align 1 + %9 = load i1, ptr %1, align 1 br label %land.end.l13 land.end.l13: ; preds = %land.1.l13, %entry.l11 - %land_phi = phi i1 [ %2, %entry.l11 ], [ %5, %land.1.l13 ] - %6 = alloca i1, align 1 - store i1 %land_phi, ptr %6, align 1 - %7 = load i1, ptr %6, align 1 - %8 = zext i1 %7 to i32 - %9 = call i32 (ptr, ...) @printf(ptr @2, i32 %8) - %10 = call i1 @_f__void__functionTrue() - %11 = alloca i1, align 1 - store i1 %10, ptr %11, align 1 - %12 = load i1, ptr %11, align 1 - br i1 %12, label %lor.end.l16, label %lor.1.l16 + %land_phi = phi i1 [ %7, %entry.l11 ], [ %9, %land.1.l13 ] + store i1 %land_phi, ptr %2, align 1 + %10 = load i1, ptr %2, align 1 + %11 = zext i1 %10 to i32 + %12 = call i32 (ptr, ...) @printf(ptr @2, i32 %11) + %13 = call i1 @_f__void__functionTrue() + store i1 %13, ptr %3, align 1 + %14 = load i1, ptr %3, align 1 + br i1 %14, label %lor.end.l16, label %lor.1.l16 lor.1.l16: ; preds = %land.end.l13 - %13 = call i1 @_f__void__functionFalse() - %14 = alloca i1, align 1 - store i1 %13, ptr %14, align 1 - %15 = load i1, ptr %14, align 1 + %15 = call i1 @_f__void__functionFalse() + store i1 %15, ptr %4, align 1 + %16 = load i1, ptr %4, align 1 br label %lor.end.l16 lor.end.l16: ; preds = %lor.1.l16, %land.end.l13 - %lor_phi = phi i1 [ %12, %land.end.l13 ], [ %15, %lor.1.l16 ] - %16 = alloca i1, align 1 - store i1 %lor_phi, ptr %16, align 1 - %17 = load i1, ptr %16, align 1 + %lor_phi = phi i1 [ %14, %land.end.l13 ], [ %16, %lor.1.l16 ] + store i1 %lor_phi, ptr %5, align 1 + %17 = load i1, ptr %5, align 1 %18 = zext i1 %17 to i32 %19 = call i32 (ptr, ...) @printf(ptr @3, i32 %18) %20 = load i32, ptr %result, align 4 diff --git a/test/test-files/generator/pointers/success-nested-pointers/ir-code.ll b/test/test-files/generator/pointers/success-nested-pointers/ir-code.ll index 3971783d3..f82f1ee15 100644 --- a/test/test-files/generator/pointers/success-nested-pointers/ir-code.ll +++ b/test/test-files/generator/pointers/success-nested-pointers/ir-code.ll @@ -48,28 +48,28 @@ declare i32 @printf(ptr, ...) define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @intArray, i32 0, i32 1), align 4 - %1 = call i32 (ptr, ...) @printf(ptr @4, i32 %0) + %0 = alloca ptr, align 8 + %1 = alloca ptr, align 8 %2 = alloca ptr, align 8 - store ptr @intArray, ptr %2, align 8 %3 = alloca ptr, align 8 - store ptr %2, ptr %3, align 8 %4 = alloca ptr, align 8 + %5 = alloca ptr, align 8 + %6 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %7 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @intArray, i32 0, i32 1), align 4 + %8 = call i32 (ptr, ...) @printf(ptr @4, i32 %7) + store ptr @intArray, ptr %0, align 8 + store ptr %0, ptr %1, align 8 + store ptr %1, ptr %2, align 8 + %9 = load ptr, ptr %2, align 8 + %10 = load ptr, ptr %9, align 8 + %11 = load ptr, ptr %10, align 8 + %12 = getelementptr inbounds [4 x i32], ptr %11, i32 0, i32 0 + store ptr %12, ptr %3, align 8 store ptr %3, ptr %4, align 8 - %5 = load ptr, ptr %4, align 8 - %6 = load ptr, ptr %5, align 8 - %7 = load ptr, ptr %6, align 8 - %8 = getelementptr inbounds [4 x i32], ptr %7, i32 0, i32 0 - %9 = alloca ptr, align 8 - store ptr %8, ptr %9, align 8 - %10 = alloca ptr, align 8 - store ptr %9, ptr %10, align 8 - %11 = alloca ptr, align 8 - store ptr %10, ptr %11, align 8 - call void @_p__void__testProc__intarrayptrptrptr(ptr %11) - %12 = alloca i1, align 1 - store i1 true, ptr %12, align 1 + store ptr %4, ptr %5, align 8 + call void @_p__void__testProc__intarrayptrptrptr(ptr %5) + store i1 true, ptr %6, align 1 %13 = load i32, ptr %result, align 4 ret i32 %13 } diff --git a/test/test-files/generator/pointers/success-pointer-functions/ir-code.ll b/test/test-files/generator/pointers/success-pointer-functions/ir-code.ll index 5a2717619..de45c039e 100644 --- a/test/test-files/generator/pointers/success-pointer-functions/ir-code.ll +++ b/test/test-files/generator/pointers/success-pointer-functions/ir-code.ll @@ -14,42 +14,42 @@ target triple = "x86_64-w64-windows-gnu" define internal void @_p__void__birthday__Personptr(ptr %0) { entry.l7: %person = alloca ptr, align 8 + %1 = alloca i32, align 4 store ptr %0, ptr %person, align 8 - %1 = load ptr, ptr %person, align 8 - %2 = getelementptr inbounds %_s__Person__string_string_int, ptr %1, i32 0, i32 2 - %3 = load i32, ptr %2, align 4 - %4 = add i32 %3, 1 - store i32 %4, ptr %2, align 4 - %5 = alloca i32, align 4 - store i32 %3, ptr %5, align 4 + %2 = load ptr, ptr %person, align 8 + %3 = getelementptr inbounds %_s__Person__string_string_int, ptr %2, i32 0, i32 2 + %4 = load i32, ptr %3, align 4 + %5 = add i32 %4, 1 + store i32 %5, ptr %3, align 4 + store i32 %4, ptr %1, align 4 ret void } define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__Person__string_string_int, align 8 - %1 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 0 - store ptr @0, ptr %1, align 8 - %2 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 1 - store ptr @1, ptr %2, align 8 - %3 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 2 - store i32 32, ptr %3, align 4 + %1 = alloca ptr, align 8 + %2 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %3 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 0 + store ptr @0, ptr %3, align 8 %4 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 1 - %5 = load ptr, ptr %4, align 8 - %6 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 0 + store ptr @1, ptr %4, align 8 + %5 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 2 + store i32 32, ptr %5, align 4 + %6 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 1 %7 = load ptr, ptr %6, align 8 - %8 = call i32 (ptr, ...) @printf(ptr @2, ptr %5, ptr %7) - %9 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 2 - %10 = load i32, ptr %9, align 4 - %11 = call i32 (ptr, ...) @printf(ptr @3, i32 %10) - %12 = alloca ptr, align 8 - store ptr %0, ptr %12, align 8 - %13 = load ptr, ptr %12, align 8 - call void @_p__void__birthday__Personptr(ptr %13) - %14 = alloca i1, align 1 - store i1 true, ptr %14, align 1 + %8 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 0 + %9 = load ptr, ptr %8, align 8 + %10 = call i32 (ptr, ...) @printf(ptr @2, ptr %7, ptr %9) + %11 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 2 + %12 = load i32, ptr %11, align 4 + %13 = call i32 (ptr, ...) @printf(ptr @3, i32 %12) + store ptr %0, ptr %1, align 8 + %14 = load ptr, ptr %1, align 8 + call void @_p__void__birthday__Personptr(ptr %14) + store i1 true, ptr %2, align 1 %15 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 2 %16 = load i32, ptr %15, align 4 %17 = call i32 (ptr, ...) @printf(ptr @4, i32 %16) diff --git a/test/test-files/generator/pointers/success-pointer/ir-code.ll b/test/test-files/generator/pointers/success-pointer/ir-code.ll index a04877078..5bf4e1a31 100644 --- a/test/test-files/generator/pointers/success-pointer/ir-code.ll +++ b/test/test-files/generator/pointers/success-pointer/ir-code.ll @@ -12,29 +12,29 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %food = alloca ptr, align 8 - store ptr @0, ptr %food, align 8 %0 = alloca ptr, align 8 + %1 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + store ptr @0, ptr %food, align 8 store ptr %food, ptr %0, align 8 - %1 = load ptr, ptr %0, align 8 %2 = load ptr, ptr %0, align 8 - %3 = load ptr, ptr %2, align 8 - store ptr %3, ptr %2, align 8 - %4 = load ptr, ptr %2, align 8 - %5 = call i32 (ptr, ...) @printf(ptr @1, ptr %1, ptr %4) - %6 = load ptr, ptr %0, align 8 - %7 = load ptr, ptr %6, align 8 - store ptr %7, ptr %6, align 8 - store ptr @2, ptr %6, align 8 - %8 = load ptr, ptr %0, align 8 - %9 = load ptr, ptr %8, align 8 - store ptr %9, ptr %8, align 8 - %10 = load ptr, ptr %8, align 8 - %11 = call i32 (ptr, ...) @printf(ptr @3, ptr %10) - %12 = alloca ptr, align 8 - store ptr %8, ptr %12, align 8 - %13 = load ptr, ptr %12, align 8 + %3 = load ptr, ptr %0, align 8 + %4 = load ptr, ptr %3, align 8 + store ptr %4, ptr %3, align 8 + %5 = load ptr, ptr %3, align 8 + %6 = call i32 (ptr, ...) @printf(ptr @1, ptr %2, ptr %5) + %7 = load ptr, ptr %0, align 8 + %8 = load ptr, ptr %7, align 8 + store ptr %8, ptr %7, align 8 + store ptr @2, ptr %7, align 8 + %9 = load ptr, ptr %0, align 8 + %10 = load ptr, ptr %9, align 8 + store ptr %10, ptr %9, align 8 + %11 = load ptr, ptr %9, align 8 + %12 = call i32 (ptr, ...) @printf(ptr @3, ptr %11) + store ptr %9, ptr %1, align 8 + %13 = load ptr, ptr %1, align 8 %14 = call i32 (ptr, ...) @printf(ptr @4, ptr %13) %15 = load i32, ptr %result, align 4 ret i32 %15 diff --git a/test/test-files/generator/procedures/success-early-return/ir-code.ll b/test/test-files/generator/procedures/success-early-return/ir-code.ll index d6fe0a7bc..58fdcaf42 100644 --- a/test/test-files/generator/procedures/success-early-return/ir-code.ll +++ b/test/test-files/generator/procedures/success-early-return/ir-code.ll @@ -25,13 +25,13 @@ declare i32 @printf(ptr, ...) define i32 @main() { entry.l6: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca i1, align 1 + %1 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i1 false, ptr %0, align 1 - %1 = load i1, ptr %0, align 1 - call void @_p__void__executeAction__bool(i1 %1) - %2 = alloca i1, align 1 - store i1 true, ptr %2, align 1 + %2 = load i1, ptr %0, align 1 + call void @_p__void__executeAction__bool(i1 %2) + store i1 true, ptr %1, align 1 %3 = load i32, ptr %result, align 4 ret i32 %3 } diff --git a/test/test-files/generator/procedures/success-explicit-inlining/ir-code.ll b/test/test-files/generator/procedures/success-explicit-inlining/ir-code.ll index 737cf42ab..a9367444d 100644 --- a/test/test-files/generator/procedures/success-explicit-inlining/ir-code.ll +++ b/test/test-files/generator/procedures/success-explicit-inlining/ir-code.ll @@ -10,10 +10,7 @@ target triple = "x86_64-w64-windows-gnu" ; Function Attrs: alwaysinline define internal void @_p__void__printAValue() #0 { entry.l1: - %0 = alloca i32, align 4 - store i32 5, ptr %0, align 4 - %1 = load i32, ptr %0, align 4 - %2 = call i32 (ptr, ...) @printf(ptr @0, i32 %1) + %0 = call i32 (ptr, ...) @printf(ptr @0, i32 5) ret void } @@ -22,11 +19,11 @@ declare i32 @printf(ptr, ...) define i32 @main() { entry.l5: %result = alloca i32, align 4 + %0 = alloca i1, align 1 store i32 0, ptr %result, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @1) + %1 = call i32 (ptr, ...) @printf(ptr @1) call void @_p__void__printAValue() - %1 = alloca i1, align 1 - store i1 true, ptr %1, align 1 + store i1 true, ptr %0, align 1 %2 = call i32 (ptr, ...) @printf(ptr @2) %3 = load i32, ptr %result, align 4 ret i32 %3 diff --git a/test/test-files/generator/structs/success-constructors/ir-code.ll b/test/test-files/generator/structs/success-constructors/ir-code.ll index ec014fd07..dc7fdb6d7 100644 --- a/test/test-files/generator/structs/success-constructors/ir-code.ll +++ b/test/test-files/generator/structs/success-constructors/ir-code.ll @@ -24,8 +24,8 @@ entry.l6: define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %vec = alloca %_s__Vector__bool_string, align 8 + store i32 0, ptr %result, align 4 call void @_mp__Vector__ctor(ptr %vec) %0 = getelementptr inbounds %_s__Vector__bool_string, ptr %vec, i32 0, i32 0 %1 = load i1, ptr %0, align 1 diff --git a/test/test-files/generator/structs/success-destructors/cout.out b/test/test-files/generator/structs/success-destructors/cout.out new file mode 100644 index 000000000..0b1458312 --- /dev/null +++ b/test/test-files/generator/structs/success-destructors/cout.out @@ -0,0 +1,2 @@ +Fields: 1, Test +Destructor called! \ No newline at end of file diff --git a/test/test-files/generator/structs/success-destructors/ir-code.ll b/test/test-files/generator/structs/success-destructors/ir-code.ll new file mode 100644 index 000000000..15e2fef59 --- /dev/null +++ b/test/test-files/generator/structs/success-destructors/ir-code.ll @@ -0,0 +1,43 @@ +; ModuleID = 'source.spice' +source_filename = "source.spice" +target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-w64-windows-gnu" + +%_s__Vector__bool_string = type { i1, ptr } + +@0 = private unnamed_addr constant [19 x i8] c"Destructor called!\00", align 1 +@1 = private unnamed_addr constant [5 x i8] c"Test\00", align 1 +@2 = private unnamed_addr constant [16 x i8] c"Fields: %d, %s\0A\00", align 1 + +define internal void @_mp__Vector__dtor(ptr %0) { +entry.l6: + %this = alloca ptr, align 8 + store ptr %0, ptr %this, align 8 + %1 = call i32 (ptr, ...) @printf(ptr @0) + ret void +} + +declare i32 @printf(ptr, ...) + +define i32 @main() { +entry.l10: + %result = alloca i32, align 4 + %0 = alloca %_s__Vector__bool_string, align 8 + store i32 0, ptr %result, align 4 + %1 = getelementptr inbounds %_s__Vector__bool_string, ptr %0, i32 0, i32 0 + store i1 true, ptr %1, align 1 + %2 = getelementptr inbounds %_s__Vector__bool_string, ptr %0, i32 0, i32 1 + store ptr @1, ptr %2, align 8 + %3 = getelementptr inbounds %_s__Vector__bool_string, ptr %0, i32 0, i32 0 + %4 = load i1, ptr %3, align 1 + %5 = zext i1 %4 to i32 + %6 = getelementptr inbounds %_s__Vector__bool_string, ptr %0, i32 0, i32 1 + %7 = load ptr, ptr %6, align 8 + %8 = call i32 (ptr, ...) @printf(ptr @2, i32 %5, ptr %7) + br label %cleanup.l10 + +cleanup.l10: ; preds = %entry.l10 + call void @_mp__Vector__dtor(ptr %0) + %9 = load i32, ptr %result, align 4 + ret i32 %9 +} diff --git a/test/test-files/generator/structs/success-destructors/source.spice b/test/test-files/generator/structs/success-destructors/source.spice new file mode 100644 index 000000000..22d73fa2c --- /dev/null +++ b/test/test-files/generator/structs/success-destructors/source.spice @@ -0,0 +1,13 @@ +type Vector struct { + bool field1 + string field2 +} + +p Vector.dtor() { + printf("Destructor called!"); +} + +f main() { + dyn vec = Vector{ true, "Test" }; + printf("Fields: %d, %s\n", vec.field1, vec.field2); +} \ No newline at end of file diff --git a/test/test-files/generator/structs/success-external-nested-struct/ir-code.ll b/test/test-files/generator/structs/success-external-nested-struct/ir-code.ll index 1422ff838..8da3715a8 100644 --- a/test/test-files/generator/structs/success-external-nested-struct/ir-code.ll +++ b/test/test-files/generator/structs/success-external-nested-struct/ir-code.ll @@ -12,18 +12,18 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %s = alloca i16, align 2 + %0 = alloca %_s__Socket__int_short_NestedSocket, align 8 + store i32 0, ptr %result, align 4 store i16 8080, ptr %s, align 2 - %0 = load i16, ptr %s, align 2 - %1 = call %_s__Socket__int_short_NestedSocket @_f__void__openServerSocket__short(i16 %0) - %2 = alloca %_s__Socket__int_short_NestedSocket, align 8 - store %_s__Socket__int_short_NestedSocket %1, ptr %2, align 8 - %3 = getelementptr inbounds %_s__Socket__int_short_NestedSocket, ptr %2, i32 0, i32 2 + %1 = load i16, ptr %s, align 2 + %2 = call %_s__Socket__int_short_NestedSocket @_f__void__openServerSocket__short(i16 %1) + store %_s__Socket__int_short_NestedSocket %2, ptr %0, align 8 + %3 = getelementptr inbounds %_s__Socket__int_short_NestedSocket, ptr %0, i32 0, i32 2 %4 = getelementptr inbounds %_s__NestedSocket__string_long, ptr %3, i32 0, i32 0 %5 = load ptr, ptr %4, align 8 %6 = call i32 (ptr, ...) @printf(ptr @0, ptr %5) - %7 = getelementptr inbounds %_s__Socket__int_short_NestedSocket, ptr %2, i32 0, i32 0 + %7 = getelementptr inbounds %_s__Socket__int_short_NestedSocket, ptr %0, i32 0, i32 0 %8 = load i32, ptr %7, align 4 %9 = call i32 (ptr, ...) @printf(ptr @1, i32 %8) %10 = load i32, ptr %result, align 4 diff --git a/test/test-files/generator/structs/success-external-structs/ir-code.ll b/test/test-files/generator/structs/success-external-structs/ir-code.ll index c7abfc14f..064ae5015 100644 --- a/test/test-files/generator/structs/success-external-structs/ir-code.ll +++ b/test/test-files/generator/structs/success-external-structs/ir-code.ll @@ -8,15 +8,15 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__Vec__int_bool, align 8 - %1 = getelementptr inbounds %_s__Vec__int_bool, ptr %0, i32 0, i32 0 - store i32 11, ptr %1, align 4 - %2 = getelementptr inbounds %_s__Vec__int_bool, ptr %0, i32 0, i32 1 - store i1 false, ptr %2, align 1 + %1 = alloca i1, align 1 + store i32 0, ptr %result, align 4 + %2 = getelementptr inbounds %_s__Vec__int_bool, ptr %0, i32 0, i32 0 + store i32 11, ptr %2, align 4 + %3 = getelementptr inbounds %_s__Vec__int_bool, ptr %0, i32 0, i32 1 + store i1 false, ptr %3, align 1 call void @_mp__Vec__print(ptr %0) - %3 = alloca i1, align 1 - store i1 true, ptr %3, align 1 + store i1 true, ptr %1, align 1 %4 = load i32, ptr %result, align 4 ret i32 %4 } diff --git a/test/test-files/generator/structs/success-struct-field-access/ir-code.ll b/test/test-files/generator/structs/success-struct-field-access/ir-code.ll index 784005cca..2b2d25c08 100644 --- a/test/test-files/generator/structs/success-struct-field-access/ir-code.ll +++ b/test/test-files/generator/structs/success-struct-field-access/ir-code.ll @@ -12,8 +12,8 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l7: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__Person__string_string_int, align 8 + store i32 0, ptr %result, align 4 %1 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 0 store ptr @0, ptr %1, align 8 %2 = getelementptr inbounds %_s__Person__string_string_int, ptr %0, i32 0, i32 1 diff --git a/test/test-files/generator/structs/success-struct-in-place/ir-code.ll b/test/test-files/generator/structs/success-struct-in-place/ir-code.ll index 2e1034859..e8e290ebd 100644 --- a/test/test-files/generator/structs/success-struct-in-place/ir-code.ll +++ b/test/test-files/generator/structs/success-struct-in-place/ir-code.ll @@ -29,51 +29,51 @@ define internal %_s__ShoppingCart__string_ShoppingItemarray @_f__void__newShoppi entry.l14: %result = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 %0 = alloca %_s__ShoppingItem__string_double_string, align 8 - %1 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 0 - store ptr @0, ptr %1, align 8 - %2 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 1 - store double 0.000000e+00, ptr %2, align 8 - %3 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 2 - store ptr @1, ptr %3, align 8 %items = alloca [3 x %_s__ShoppingItem__string_double_string], align 8 + %1 = alloca %_s__ShoppingItem__string_double_string, align 8 + %2 = alloca %_s__ShoppingItem__string_double_string, align 8 + %3 = alloca %_s__ShoppingItem__string_double_string, align 8 + %4 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 + %5 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 0 + store ptr @0, ptr %5, align 8 + %6 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 1 + store double 0.000000e+00, ptr %6, align 8 + %7 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 2 + store ptr @1, ptr %7, align 8 store [3 x %_s__ShoppingItem__string_double_string] [%_s__ShoppingItem__string_double_string { ptr @0, double 0.000000e+00, ptr @1 }, %_s__ShoppingItem__string_double_string { ptr @0, double 0.000000e+00, ptr @1 }, %_s__ShoppingItem__string_double_string { ptr @0, double 0.000000e+00, ptr @1 }], ptr %items, align 8 - %4 = alloca %_s__ShoppingItem__string_double_string, align 8 - %5 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %4, i32 0, i32 0 - store ptr @2, ptr %5, align 8 - %6 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %4, i32 0, i32 1 - store double 1.000000e+02, ptr %6, align 8 - %7 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %4, i32 0, i32 2 - store ptr @3, ptr %7, align 8 - %8 = load %_s__ShoppingItem__string_double_string, ptr %4, align 8 - %9 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 0 - store %_s__ShoppingItem__string_double_string %8, ptr %9, align 8 - %10 = alloca %_s__ShoppingItem__string_double_string, align 8 - %11 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 0 - store ptr @4, ptr %11, align 8 - %12 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 1 - store double 1.255000e+02, ptr %12, align 8 - %13 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 2 - store ptr @5, ptr %13, align 8 - %14 = load %_s__ShoppingItem__string_double_string, ptr %10, align 8 - %15 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 1 - store %_s__ShoppingItem__string_double_string %14, ptr %15, align 8 - %16 = alloca %_s__ShoppingItem__string_double_string, align 8 - %17 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %16, i32 0, i32 0 - store ptr @6, ptr %17, align 8 - %18 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %16, i32 0, i32 1 - store double 6.000000e+00, ptr %18, align 8 - %19 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %16, i32 0, i32 2 - store ptr @7, ptr %19, align 8 - %20 = load %_s__ShoppingItem__string_double_string, ptr %16, align 8 - %21 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 2 - store %_s__ShoppingItem__string_double_string %20, ptr %21, align 8 - %22 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 - %23 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %22, i32 0, i32 0 + %8 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 0 + store ptr @2, ptr %8, align 8 + %9 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 1 + store double 1.000000e+02, ptr %9, align 8 + %10 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 2 + store ptr @3, ptr %10, align 8 + %11 = load %_s__ShoppingItem__string_double_string, ptr %1, align 8 + %12 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 0 + store %_s__ShoppingItem__string_double_string %11, ptr %12, align 8 + %13 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 0 + store ptr @4, ptr %13, align 8 + %14 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 1 + store double 1.255000e+02, ptr %14, align 8 + %15 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 2 + store ptr @5, ptr %15, align 8 + %16 = load %_s__ShoppingItem__string_double_string, ptr %2, align 8 + %17 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 1 + store %_s__ShoppingItem__string_double_string %16, ptr %17, align 8 + %18 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %3, i32 0, i32 0 + store ptr @6, ptr %18, align 8 + %19 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %3, i32 0, i32 1 + store double 6.000000e+00, ptr %19, align 8 + %20 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %3, i32 0, i32 2 + store ptr @7, ptr %20, align 8 + %21 = load %_s__ShoppingItem__string_double_string, ptr %3, align 8 + %22 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %items, i32 0, i32 2 + store %_s__ShoppingItem__string_double_string %21, ptr %22, align 8 + %23 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, i32 0, i32 0 store ptr @8, ptr %23, align 8 %24 = load [3 x %_s__ShoppingItem__string_double_string], ptr %items, align 8 - %25 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %22, i32 0, i32 1 + %25 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, i32 0, i32 1 store [3 x %_s__ShoppingItem__string_double_string] %24, ptr %25, align 8 - %26 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %22, align 8 + %26 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, align 8 ret %_s__ShoppingCart__string_ShoppingItemarray %26 } @@ -81,64 +81,64 @@ define internal %_s__ShoppingCart__string_ShoppingItemarray @_f__void__anotherSh entry.l22: %result = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 %0 = alloca %_s__ShoppingItem__string_double_string, align 8 - %1 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 0 - store ptr @9, ptr %1, align 8 - %2 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 1 - store double 1.000000e+02, ptr %2, align 8 - %3 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 2 - store ptr @10, ptr %3, align 8 - %4 = load %_s__ShoppingItem__string_double_string, ptr %0, align 8 - %5 = alloca %_s__ShoppingItem__string_double_string, align 8 - %6 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %5, i32 0, i32 0 - store ptr @11, ptr %6, align 8 - %7 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %5, i32 0, i32 1 - store double 1.255000e+02, ptr %7, align 8 - %8 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %5, i32 0, i32 2 - store ptr @12, ptr %8, align 8 - %9 = load %_s__ShoppingItem__string_double_string, ptr %5, align 8 - %10 = alloca %_s__ShoppingItem__string_double_string, align 8 - %11 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 0 - store ptr @13, ptr %11, align 8 - %12 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 1 - store double 6.000000e+00, ptr %12, align 8 - %13 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %10, i32 0, i32 2 - store ptr @14, ptr %13, align 8 - %14 = load %_s__ShoppingItem__string_double_string, ptr %10, align 8 - %15 = alloca [3 x %_s__ShoppingItem__string_double_string], align 8 - %16 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %15, i32 0, i32 0 - store %_s__ShoppingItem__string_double_string %4, ptr %16, align 8 - %17 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %15, i32 0, i32 1 - store %_s__ShoppingItem__string_double_string %9, ptr %17, align 8 - %18 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %15, i32 0, i32 2 - store %_s__ShoppingItem__string_double_string %14, ptr %18, align 8 - %19 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 - %20 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %19, i32 0, i32 0 + %1 = alloca %_s__ShoppingItem__string_double_string, align 8 + %2 = alloca %_s__ShoppingItem__string_double_string, align 8 + %3 = alloca [3 x %_s__ShoppingItem__string_double_string], align 8 + %4 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 + %5 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 0 + store ptr @9, ptr %5, align 8 + %6 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 1 + store double 1.000000e+02, ptr %6, align 8 + %7 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %0, i32 0, i32 2 + store ptr @10, ptr %7, align 8 + %8 = load %_s__ShoppingItem__string_double_string, ptr %0, align 8 + %9 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 0 + store ptr @11, ptr %9, align 8 + %10 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 1 + store double 1.255000e+02, ptr %10, align 8 + %11 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %1, i32 0, i32 2 + store ptr @12, ptr %11, align 8 + %12 = load %_s__ShoppingItem__string_double_string, ptr %1, align 8 + %13 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 0 + store ptr @13, ptr %13, align 8 + %14 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 1 + store double 6.000000e+00, ptr %14, align 8 + %15 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %2, i32 0, i32 2 + store ptr @14, ptr %15, align 8 + %16 = load %_s__ShoppingItem__string_double_string, ptr %2, align 8 + %17 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %3, i32 0, i32 0 + store %_s__ShoppingItem__string_double_string %8, ptr %17, align 8 + %18 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %3, i32 0, i32 1 + store %_s__ShoppingItem__string_double_string %12, ptr %18, align 8 + %19 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %3, i32 0, i32 2 + store %_s__ShoppingItem__string_double_string %16, ptr %19, align 8 + %20 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, i32 0, i32 0 store ptr @15, ptr %20, align 8 - %21 = load [3 x %_s__ShoppingItem__string_double_string], ptr %15, align 8 - %22 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %19, i32 0, i32 1 + %21 = load [3 x %_s__ShoppingItem__string_double_string], ptr %3, align 8 + %22 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, i32 0, i32 1 store [3 x %_s__ShoppingItem__string_double_string] %21, ptr %22, align 8 - %23 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %19, align 8 + %23 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %4, align 8 ret %_s__ShoppingCart__string_ShoppingItemarray %23 } define i32 @main() { entry.l31: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call %_s__ShoppingCart__string_ShoppingItemarray @_f__void__newShoppingCart() + %0 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 %1 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 - store %_s__ShoppingCart__string_ShoppingItemarray %0, ptr %1, align 8 - %2 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %1, i32 0, i32 1 - %3 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %2, i32 0, i32 1 - %4 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %3, i32 0, i32 0 - %5 = load ptr, ptr %4, align 8 - %6 = call i32 (ptr, ...) @printf(ptr @16, ptr %5) - %7 = call %_s__ShoppingCart__string_ShoppingItemarray @_f__void__anotherShoppingCart() - %8 = alloca %_s__ShoppingCart__string_ShoppingItemarray, align 8 - store %_s__ShoppingCart__string_ShoppingItemarray %7, ptr %8, align 8 - %9 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %8, align 8 - store %_s__ShoppingCart__string_ShoppingItemarray %9, ptr %1, align 8 - %10 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %1, i32 0, i32 1 + store i32 0, ptr %result, align 4 + %2 = call %_s__ShoppingCart__string_ShoppingItemarray @_f__void__newShoppingCart() + store %_s__ShoppingCart__string_ShoppingItemarray %2, ptr %0, align 8 + %3 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %0, i32 0, i32 1 + %4 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %3, i32 0, i32 1 + %5 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %4, i32 0, i32 0 + %6 = load ptr, ptr %5, align 8 + %7 = call i32 (ptr, ...) @printf(ptr @16, ptr %6) + %8 = call %_s__ShoppingCart__string_ShoppingItemarray @_f__void__anotherShoppingCart() + store %_s__ShoppingCart__string_ShoppingItemarray %8, ptr %1, align 8 + %9 = load %_s__ShoppingCart__string_ShoppingItemarray, ptr %1, align 8 + store %_s__ShoppingCart__string_ShoppingItemarray %9, ptr %0, align 8 + %10 = getelementptr inbounds %_s__ShoppingCart__string_ShoppingItemarray, ptr %0, i32 0, i32 1 %11 = getelementptr inbounds [3 x %_s__ShoppingItem__string_double_string], ptr %10, i32 0, i32 2 %12 = getelementptr inbounds %_s__ShoppingItem__string_double_string, ptr %11, i32 0, i32 2 %13 = load ptr, ptr %12, align 8 diff --git a/test/test-files/generator/structs/success-struct-self-ref/ir-code.ll b/test/test-files/generator/structs/success-struct-self-ref/ir-code.ll index e13fc5721..90a15c685 100644 --- a/test/test-files/generator/structs/success-struct-self-ref/ir-code.ll +++ b/test/test-files/generator/structs/success-struct-self-ref/ir-code.ll @@ -10,65 +10,65 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l13: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %0 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 %rootNode = alloca ptr, align 8 + %1 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 + %2 = alloca ptr, align 8 + %3 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 + %4 = alloca ptr, align 8 + %5 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 + %6 = alloca ptr, align 8 + %7 = alloca ptr, align 8 + %8 = alloca ptr, align 8 + %9 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store ptr null, ptr %rootNode, align 8 - %1 = load ptr, ptr %rootNode, align 8 - %2 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %0, i32 0, i32 0 - store ptr %1, ptr %2, align 8 - %3 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %0, i32 0, i32 1 - store i32 0, ptr %3, align 4 - %4 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 - %5 = alloca ptr, align 8 - store ptr %0, ptr %5, align 8 - %6 = load ptr, ptr %5, align 8 - %7 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %4, i32 0, i32 0 - store ptr %6, ptr %7, align 8 - %8 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %4, i32 0, i32 1 - store i32 1, ptr %8, align 4 - %9 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 - %10 = alloca ptr, align 8 - store ptr %0, ptr %10, align 8 - %11 = load ptr, ptr %10, align 8 - %12 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %9, i32 0, i32 0 - store ptr %11, ptr %12, align 8 - %13 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %9, i32 0, i32 1 - store i32 2, ptr %13, align 4 - %14 = alloca %_s__TreeNode__TreeNodeptr_int, align 8 - %15 = alloca ptr, align 8 - store ptr %9, ptr %15, align 8 - %16 = load ptr, ptr %15, align 8 - %17 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %14, i32 0, i32 0 + %10 = load ptr, ptr %rootNode, align 8 + %11 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %0, i32 0, i32 0 + store ptr %10, ptr %11, align 8 + %12 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %0, i32 0, i32 1 + store i32 0, ptr %12, align 4 + store ptr %0, ptr %2, align 8 + %13 = load ptr, ptr %2, align 8 + %14 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %1, i32 0, i32 0 + store ptr %13, ptr %14, align 8 + %15 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %1, i32 0, i32 1 + store i32 1, ptr %15, align 4 + store ptr %0, ptr %4, align 8 + %16 = load ptr, ptr %4, align 8 + %17 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %3, i32 0, i32 0 store ptr %16, ptr %17, align 8 - %18 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %14, i32 0, i32 1 - store i32 3, ptr %18, align 4 - %19 = alloca ptr, align 8 - store ptr %14, ptr %19, align 8 + %18 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %3, i32 0, i32 1 + store i32 2, ptr %18, align 4 + store ptr %3, ptr %6, align 8 + %19 = load ptr, ptr %6, align 8 + %20 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %5, i32 0, i32 0 + store ptr %19, ptr %20, align 8 + %21 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %5, i32 0, i32 1 + store i32 3, ptr %21, align 4 + store ptr %5, ptr %7, align 8 br label %while.cond.l21 while.cond.l21: ; preds = %while.l21, %entry.l13 - %20 = load ptr, ptr %19, align 8 - %21 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %20, i32 0, i32 0 - %22 = load ptr, ptr %21, align 8 - %23 = alloca ptr, align 8 - store ptr null, ptr %23, align 8 + %22 = load ptr, ptr %7, align 8 + %23 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %22, i32 0, i32 0 %24 = load ptr, ptr %23, align 8 - %25 = icmp ne ptr %22, %24 - %26 = alloca i1, align 1 - store i1 %25, ptr %26, align 1 - %27 = load i1, ptr %26, align 1 + store ptr null, ptr %8, align 8 + %25 = load ptr, ptr %8, align 8 + %26 = icmp ne ptr %24, %25 + store i1 %26, ptr %9, align 1 + %27 = load i1, ptr %9, align 1 br i1 %27, label %while.l21, label %while.end.l21 while.l21: ; preds = %while.cond.l21 - %28 = load ptr, ptr %19, align 8 + %28 = load ptr, ptr %7, align 8 %29 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %28, i32 0, i32 0 %30 = load ptr, ptr %29, align 8 - store ptr %30, ptr %19, align 8 + store ptr %30, ptr %7, align 8 br label %while.cond.l21 while.end.l21: ; preds = %while.cond.l21 - %31 = load ptr, ptr %19, align 8 + %31 = load ptr, ptr %7, align 8 %32 = getelementptr inbounds %_s__TreeNode__TreeNodeptr_int, ptr %31, i32 0, i32 1 %33 = load i32, ptr %32, align 4 %34 = call i32 (ptr, ...) @printf(ptr @0, i32 %33) diff --git a/test/test-files/generator/structs/success-struct/ir-code.ll b/test/test-files/generator/structs/success-struct/ir-code.ll index 89106cded..d88703b4b 100644 --- a/test/test-files/generator/structs/success-struct/ir-code.ll +++ b/test/test-files/generator/structs/success-struct/ir-code.ll @@ -13,33 +13,33 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l12: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %input = alloca i32, align 4 - store i32 12, ptr %input, align 4 %boolean = alloca i1, align 1 - store i1 true, ptr %boolean, align 1 %0 = alloca %_s__Nested__string_boolptr, align 8 - %1 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %0, i32 0, i32 0 - store ptr @0, ptr %1, align 8 - %2 = alloca ptr, align 8 - store ptr %boolean, ptr %2, align 8 - %3 = load ptr, ptr %2, align 8 - %4 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %0, i32 0, i32 1 - store ptr %3, ptr %4, align 8 - %5 = alloca %_s__TestStruct__intptr_double_Nestedptr, align 8 - %6 = alloca ptr, align 8 - store ptr %input, ptr %6, align 8 - %7 = load ptr, ptr %6, align 8 - %8 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 0 - store ptr %7, ptr %8, align 8 - %9 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 1 - store double 4.634000e+01, ptr %9, align 8 - %10 = alloca ptr, align 8 - store ptr %0, ptr %10, align 8 - %11 = load ptr, ptr %10, align 8 - %12 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 2 + %1 = alloca ptr, align 8 + %2 = alloca %_s__TestStruct__intptr_double_Nestedptr, align 8 + %3 = alloca ptr, align 8 + %4 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + store i32 12, ptr %input, align 4 + store i1 true, ptr %boolean, align 1 + %5 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %0, i32 0, i32 0 + store ptr @0, ptr %5, align 8 + store ptr %boolean, ptr %1, align 8 + %6 = load ptr, ptr %1, align 8 + %7 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %0, i32 0, i32 1 + store ptr %6, ptr %7, align 8 + store ptr %input, ptr %3, align 8 + %8 = load ptr, ptr %3, align 8 + %9 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 0 + store ptr %8, ptr %9, align 8 + %10 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 1 + store double 4.634000e+01, ptr %10, align 8 + store ptr %0, ptr %4, align 8 + %11 = load ptr, ptr %4, align 8 + %12 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 2 store ptr %11, ptr %12, align 8 - %13 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 2 + %13 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 2 %14 = load ptr, ptr %13, align 8 %15 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %14, i32 0, i32 1 %16 = load ptr, ptr %15, align 8 @@ -47,10 +47,10 @@ entry.l12: store i1 %17, ptr %16, align 1 %18 = load i1, ptr %16, align 1 %19 = zext i1 %18 to i32 - %20 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 1 + %20 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 1 %21 = load double, ptr %20, align 8 %22 = call i32 (ptr, ...) @printf(ptr @1, i32 %19, double %21) - %23 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %5, i32 0, i32 2 + %23 = getelementptr inbounds %_s__TestStruct__intptr_double_Nestedptr, ptr %2, i32 0, i32 2 %24 = load ptr, ptr %23, align 8 %25 = getelementptr inbounds %_s__Nested__string_boolptr, ptr %24, i32 0, i32 0 %26 = load ptr, ptr %25, align 8 diff --git a/test/test-files/generator/ternary/success-shortened-ternary/ir-code.ll b/test/test-files/generator/ternary/success-shortened-ternary/ir-code.ll index 4ba0927fa..11b80a86d 100644 --- a/test/test-files/generator/ternary/success-shortened-ternary/ir-code.ll +++ b/test/test-files/generator/ternary/success-shortened-ternary/ir-code.ll @@ -10,10 +10,10 @@ target triple = "x86_64-w64-windows-gnu" define internal i1 @_f__void__f1() { entry.l1: %result = alloca i1, align 1 - %0 = call i32 (ptr, ...) @printf(ptr @0) - %1 = alloca i1, align 1 - store i1 false, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 + %0 = alloca i1, align 1 + %1 = call i32 (ptr, ...) @printf(ptr @0) + store i1 false, ptr %0, align 1 + %2 = load i1, ptr %0, align 1 ret i1 %2 } @@ -22,25 +22,25 @@ declare i32 @printf(ptr, ...) define internal i1 @_f__void__f2() { entry.l6: %result = alloca i1, align 1 - %0 = call i32 (ptr, ...) @printf(ptr @1) - %1 = alloca i1, align 1 - store i1 true, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 + %0 = alloca i1, align 1 + %1 = call i32 (ptr, ...) @printf(ptr @1) + store i1 true, ptr %0, align 1 + %2 = load i1, ptr %0, align 1 ret i1 %2 } define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i1 @_f__void__f1() + %0 = alloca i1, align 1 %1 = alloca i1, align 1 - store i1 %0, ptr %1, align 1 - %2 = call i1 @_f__void__f2() - %3 = alloca i1, align 1 - store i1 %2, ptr %3, align 1 - %4 = load i1, ptr %1, align 1 - %5 = select i1 %4, ptr %1, ptr %3 + store i32 0, ptr %result, align 4 + %2 = call i1 @_f__void__f1() + store i1 %2, ptr %0, align 1 + %3 = call i1 @_f__void__f2() + store i1 %3, ptr %1, align 1 + %4 = load i1, ptr %0, align 1 + %5 = select i1 %4, ptr %0, ptr %1 %6 = load i1, ptr %5, align 1 %7 = zext i1 %6 to i32 %8 = call i32 (ptr, ...) @printf(ptr @2, i32 %7) diff --git a/test/test-files/generator/ternary/success-ternary-short-circuiting/ir-code.ll b/test/test-files/generator/ternary/success-ternary-short-circuiting/ir-code.ll index 1cfd51b80..8a7c32f1f 100644 --- a/test/test-files/generator/ternary/success-ternary-short-circuiting/ir-code.ll +++ b/test/test-files/generator/ternary/success-ternary-short-circuiting/ir-code.ll @@ -26,30 +26,30 @@ entry.l5: define i32 @main() { entry.l9: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i1 @_f__void__condition1() + %0 = alloca i1, align 1 %1 = alloca i1, align 1 - store i1 %0, ptr %1, align 1 - %2 = load i1, ptr %1, align 1 - br i1 %2, label %land.1.l10, label %land.end.l10 + %2 = alloca i1, align 1 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + %5 = call i1 @_f__void__condition1() + store i1 %5, ptr %0, align 1 + %6 = load i1, ptr %0, align 1 + br i1 %6, label %land.1.l10, label %land.end.l10 land.1.l10: ; preds = %entry.l9 - %3 = call i1 @_f__void__condition2() - %4 = alloca i1, align 1 - store i1 %3, ptr %4, align 1 - %5 = load i1, ptr %4, align 1 + %7 = call i1 @_f__void__condition2() + store i1 %7, ptr %1, align 1 + %8 = load i1, ptr %1, align 1 br label %land.end.l10 land.end.l10: ; preds = %land.1.l10, %entry.l9 - %land_phi = phi i1 [ %2, %entry.l9 ], [ %5, %land.1.l10 ] - %6 = alloca i1, align 1 - store i1 %land_phi, ptr %6, align 1 - %7 = alloca i32, align 4 - store i32 2, ptr %7, align 4 - %8 = alloca i32, align 4 - store i32 3, ptr %8, align 4 - %9 = load i1, ptr %6, align 1 - %10 = select i1 %9, ptr %7, ptr %8 + %land_phi = phi i1 [ %6, %entry.l9 ], [ %8, %land.1.l10 ] + store i1 %land_phi, ptr %2, align 1 + store i32 2, ptr %3, align 4 + store i32 3, ptr %4, align 4 + %9 = load i1, ptr %2, align 1 + %10 = select i1 %9, ptr %3, ptr %4 %11 = load i32, ptr %10, align 4 %12 = call i32 (ptr, ...) @printf(ptr @0, i32 %11) %13 = load i32, ptr %result, align 4 diff --git a/test/test-files/generator/ternary/success-ternary-stmt/ir-code.ll b/test/test-files/generator/ternary/success-ternary-stmt/ir-code.ll index 314646207..9caffc9b2 100644 --- a/test/test-files/generator/ternary/success-ternary-stmt/ir-code.ll +++ b/test/test-files/generator/ternary/success-ternary-stmt/ir-code.ll @@ -17,16 +17,16 @@ entry.l1: define i32 @main() { entry.l5: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %condition = alloca i1, align 1 - store i1 true, ptr %condition, align 1 - %0 = call i32 @_f__void__get() - %1 = alloca i32, align 4 - store i32 %0, ptr %1, align 4 + %0 = alloca i32, align 4 %r = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store i1 true, ptr %condition, align 1 + %1 = call i32 @_f__void__get() + store i32 %1, ptr %0, align 4 store i32 24, ptr %r, align 4 %2 = load i1, ptr %condition, align 1 - %3 = select i1 %2, ptr %1, ptr %r + %3 = select i1 %2, ptr %0, ptr %r %4 = load i32, ptr %3, align 4 %5 = call i32 (ptr, ...) @printf(ptr @0, i32 %4) %6 = load i32, ptr %result, align 4 diff --git a/test/test-files/generator/threads/success-basic-threads/ir-code.ll b/test/test-files/generator/threads/success-basic-threads/ir-code.ll index feb3a42b2..51637282d 100644 --- a/test/test-files/generator/threads/success-basic-threads/ir-code.ll +++ b/test/test-files/generator/threads/success-basic-threads/ir-code.ll @@ -13,23 +13,27 @@ declare i32 @usleep(i32) define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @0) + %0 = alloca {}, align 8 %1 = alloca {}, align 8 - %2 = alloca ptr, align 8 - %3 = call i32 @pthread_create(ptr %2, ptr null, ptr @_thread0, ptr %1) - %4 = alloca {}, align 8 - %5 = alloca ptr, align 8 - %6 = call i32 @pthread_create(ptr %5, ptr null, ptr @_thread1, ptr %4) - %7 = alloca i32, align 4 - store i32 1000000, ptr %7, align 4 - %8 = load i32, ptr %7, align 4 - %9 = call i32 @usleep(i32 %8) - %10 = alloca i32, align 4 - store i32 %9, ptr %10, align 4 - %11 = call i32 (ptr, ...) @printf(ptr @3) - %12 = load i32, ptr %result, align 4 - ret i32 %12 + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + %6 = call i32 (ptr, ...) @printf(ptr @0) + %7 = alloca ptr, align 8 + %8 = call i32 @pthread_create(ptr %7, ptr null, ptr @_thread0, ptr %0) + %9 = alloca ptr, align 8 + %10 = call i32 @pthread_create(ptr %9, ptr null, ptr @_thread1, ptr %1) + store i32 1000, ptr %2, align 4 + store i32 1000, ptr %3, align 4 + store i32 1000000, ptr %4, align 4 + %11 = load i32, ptr %4, align 4 + %12 = call i32 @usleep(i32 %11) + store i32 %12, ptr %5, align 4 + %13 = call i32 (ptr, ...) @printf(ptr @3) + %14 = load i32, ptr %result, align 4 + ret i32 %14 } declare i32 @printf(ptr, ...) @@ -37,12 +41,16 @@ declare i32 @printf(ptr, ...) define internal ptr @_thread0(ptr %0) { thread.entry.l5: %1 = alloca i32, align 4 - store i32 500000, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 - %3 = call i32 @usleep(i32 %2) + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 - %5 = call i32 (ptr, ...) @printf(ptr @1) + store i32 500, ptr %1, align 4 + store i32 1000, ptr %2, align 4 + store i32 500000, ptr %3, align 4 + %5 = load i32, ptr %3, align 4 + %6 = call i32 @usleep(i32 %5) + store i32 %6, ptr %4, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @1) ret ptr null } @@ -51,11 +59,15 @@ declare i32 @pthread_create(ptr, ptr, ptr, ptr) define internal ptr @_thread1(ptr %0) { thread.entry.l9: %1 = alloca i32, align 4 - store i32 200000, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 - %3 = call i32 @usleep(i32 %2) + %2 = alloca i32, align 4 + %3 = alloca i32, align 4 %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 - %5 = call i32 (ptr, ...) @printf(ptr @2) + store i32 200, ptr %1, align 4 + store i32 1000, ptr %2, align 4 + store i32 200000, ptr %3, align 4 + %5 = load i32, ptr %3, align 4 + %6 = call i32 @usleep(i32 %5) + store i32 %6, ptr %4, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @2) ret ptr null } diff --git a/test/test-files/generator/threads/success-thread-joining/ir-code-O2.ll b/test/test-files/generator/threads/success-thread-joining/ir-code-O2.ll index 4600bb16c..2540f5325 100644 --- a/test/test-files/generator/threads/success-thread-joining/ir-code-O2.ll +++ b/test/test-files/generator/threads/success-thread-joining/ir-code-O2.ll @@ -15,17 +15,17 @@ entry.l3: %0 = alloca {}, align 8 %t1 = alloca ptr, align 8 %t3 = alloca ptr, align 8 + %1 = alloca { ptr, ptr }, align 8 store ptr null, ptr %t3, align 8 - %1 = alloca ptr, align 8 - %2 = call i32 @pthread_create(ptr nonnull %1, ptr null, ptr nonnull @_thread0, ptr nonnull %0) - %3 = load ptr, ptr %1, align 8 - store ptr %3, ptr %t1, align 8 - %4 = alloca { ptr, ptr }, align 8 - store ptr %t1, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, ptr }, ptr %4, i64 0, i32 1 + %2 = alloca ptr, align 8 + %3 = call i32 @pthread_create(ptr nonnull %2, ptr null, ptr nonnull @_thread0, ptr nonnull %0) + %4 = load ptr, ptr %2, align 8 + store ptr %4, ptr %t1, align 8 + store ptr %t1, ptr %1, align 8 + %5 = getelementptr inbounds { ptr, ptr }, ptr %1, i64 0, i32 1 store ptr %t3, ptr %5, align 8 %6 = alloca ptr, align 8 - %7 = call i32 @pthread_create(ptr nonnull %6, ptr null, ptr nonnull @_thread1, ptr nonnull %4) + %7 = call i32 @pthread_create(ptr nonnull %6, ptr null, ptr nonnull @_thread1, ptr nonnull %1) %8 = load ptr, ptr %6, align 8 %9 = alloca ptr, align 8 %10 = call i32 @pthread_create(ptr nonnull %9, ptr null, ptr nonnull @_thread2, ptr nonnull %0) diff --git a/test/test-files/generator/threads/success-thread-joining/ir-code.ll b/test/test-files/generator/threads/success-thread-joining/ir-code.ll index 34f807652..a7d7be5d1 100644 --- a/test/test-files/generator/threads/success-thread-joining/ir-code.ll +++ b/test/test-files/generator/threads/success-thread-joining/ir-code.ll @@ -13,36 +13,36 @@ declare i32 @usleep(i32) define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %t1 = alloca ptr, align 8 - store ptr null, ptr %t1, align 8 %t2 = alloca ptr, align 8 - store ptr null, ptr %t2, align 8 %t3 = alloca ptr, align 8 - store ptr null, ptr %t3, align 8 %0 = alloca {}, align 8 - %1 = alloca ptr, align 8 - %2 = call i32 @pthread_create(ptr %1, ptr null, ptr @_thread0, ptr %0) - %3 = load ptr, ptr %1, align 8 - store ptr %3, ptr %t1, align 8 - %4 = alloca { ptr, ptr }, align 8 - %5 = getelementptr inbounds { ptr, ptr }, ptr %4, i32 0, i32 0 - store ptr %t1, ptr %5, align 8 - %6 = getelementptr inbounds { ptr, ptr }, ptr %4, i32 0, i32 1 - store ptr %t3, ptr %6, align 8 - %7 = alloca ptr, align 8 - %8 = call i32 @pthread_create(ptr %7, ptr null, ptr @_thread1, ptr %4) - %9 = load ptr, ptr %7, align 8 - store ptr %9, ptr %t2, align 8 - %10 = alloca {}, align 8 - %11 = alloca ptr, align 8 - %12 = call i32 @pthread_create(ptr %11, ptr null, ptr @_thread2, ptr %10) - %13 = load ptr, ptr %11, align 8 - store ptr %13, ptr %t3, align 8 - %14 = load ptr, ptr %t2, align 8 - %15 = call i32 @pthread_join(ptr %14, ptr null) - %16 = alloca i32, align 4 - store i32 1, ptr %16, align 4 + %1 = alloca { ptr, ptr }, align 8 + %2 = alloca {}, align 8 + %3 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + store ptr null, ptr %t1, align 8 + store ptr null, ptr %t2, align 8 + store ptr null, ptr %t3, align 8 + %4 = alloca ptr, align 8 + %5 = call i32 @pthread_create(ptr %4, ptr null, ptr @_thread0, ptr %0) + %6 = load ptr, ptr %4, align 8 + store ptr %6, ptr %t1, align 8 + %7 = getelementptr inbounds { ptr, ptr }, ptr %1, i32 0, i32 0 + store ptr %t1, ptr %7, align 8 + %8 = getelementptr inbounds { ptr, ptr }, ptr %1, i32 0, i32 1 + store ptr %t3, ptr %8, align 8 + %9 = alloca ptr, align 8 + %10 = call i32 @pthread_create(ptr %9, ptr null, ptr @_thread1, ptr %1) + %11 = load ptr, ptr %9, align 8 + store ptr %11, ptr %t2, align 8 + %12 = alloca ptr, align 8 + %13 = call i32 @pthread_create(ptr %12, ptr null, ptr @_thread2, ptr %2) + %14 = load ptr, ptr %12, align 8 + store ptr %14, ptr %t3, align 8 + %15 = load ptr, ptr %t2, align 8 + %16 = call i32 @pthread_join(ptr %15, ptr null) + store i32 1, ptr %3, align 4 %17 = call i32 (ptr, ...) @printf(ptr @3) %18 = load i32, ptr %result, align 4 ret i32 %18 @@ -50,12 +50,16 @@ entry.l3: define internal ptr @_thread0(ptr %0) { thread.entry.l8: + %t1 = alloca i32, align 4 + %t11 = alloca i32, align 4 %1 = alloca i32, align 4 + %2 = alloca i32, align 4 + store i32 300, ptr %t1, align 4 + store i32 1000, ptr %t11, align 4 store i32 300000, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 - %3 = call i32 @usleep(i32 %2) - %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 + %3 = load i32, ptr %1, align 4 + %4 = call i32 @usleep(i32 %3) + store i32 %4, ptr %2, align 4 %5 = call i32 (ptr, ...) @printf(ptr @0) ret ptr null } @@ -84,12 +88,16 @@ declare i32 @pthread_join(ptr, ptr) define internal ptr @_thread2(ptr %0) { thread.entry.l18: + %t3 = alloca i32, align 4 + %t31 = alloca i32, align 4 %1 = alloca i32, align 4 + %2 = alloca i32, align 4 + store i32 200, ptr %t3, align 4 + store i32 1000, ptr %t31, align 4 store i32 200000, ptr %1, align 4 - %2 = load i32, ptr %1, align 4 - %3 = call i32 @usleep(i32 %2) - %4 = alloca i32, align 4 - store i32 %3, ptr %4, align 4 + %3 = load i32, ptr %1, align 4 + %4 = call i32 @usleep(i32 %3) + store i32 %4, ptr %2, align 4 %5 = call i32 (ptr, ...) @printf(ptr @2) ret ptr null } diff --git a/test/test-files/generator/threads/success-threads-captures1/ir-code-O2.ll b/test/test-files/generator/threads/success-threads-captures1/ir-code-O2.ll index 25c2b7ffe..0f6a381ac 100644 --- a/test/test-files/generator/threads/success-threads-captures1/ir-code-O2.ll +++ b/test/test-files/generator/threads/success-threads-captures1/ir-code-O2.ll @@ -12,18 +12,18 @@ declare i32 @usleep(i32) local_unnamed_addr define i32 @main() local_unnamed_addr { entry.l3: - %puts = tail call i32 @puts(ptr nonnull @str) %i = alloca i32, align 4 + %0 = alloca { ptr }, align 8 + %puts = tail call i32 @puts(ptr nonnull @str) store i32 1, ptr %i, align 4 br label %for.l5 for.l5: ; preds = %entry.l3, %for.l5 %storemerge2 = phi i32 [ 1, %entry.l3 ], [ %5, %for.l5 ] - %0 = call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %storemerge2) - %1 = alloca { ptr }, align 8 - store ptr %i, ptr %1, align 8 + %1 = call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %storemerge2) + store ptr %i, ptr %0, align 8 %2 = alloca ptr, align 8 - %3 = call i32 @pthread_create(ptr nonnull %2, ptr null, ptr nonnull @_thread0, ptr nonnull %1) + %3 = call i32 @pthread_create(ptr nonnull %2, ptr null, ptr nonnull @_thread0, ptr nonnull %0) %4 = load i32, ptr %i, align 4 %5 = add i32 %4, 1 store i32 %5, ptr %i, align 4 diff --git a/test/test-files/generator/threads/success-threads-captures1/ir-code.ll b/test/test-files/generator/threads/success-threads-captures1/ir-code.ll index c171d762d..bb9821898 100644 --- a/test/test-files/generator/threads/success-threads-captures1/ir-code.ll +++ b/test/test-files/generator/threads/success-threads-captures1/ir-code.ll @@ -13,48 +13,52 @@ declare i32 @usleep(i32) define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @0) %i = alloca i32, align 4 + %0 = alloca { ptr }, align 8 + %1 = alloca i32, align 4 + %2 = alloca i1, align 1 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 + %6 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @0) store i32 1, ptr %i, align 4 br label %for.cond.l5 for.l5: ; preds = %for.cond.l5 - %1 = load i32, ptr %i, align 4 - %2 = call i32 (ptr, ...) @printf(ptr @1, i32 %1) - %3 = alloca { ptr }, align 8 - %4 = getelementptr inbounds { ptr }, ptr %3, i32 0, i32 0 - store ptr %i, ptr %4, align 8 - %5 = alloca ptr, align 8 - %6 = call i32 @pthread_create(ptr %5, ptr null, ptr @_thread0, ptr %3) + %8 = load i32, ptr %i, align 4 + %9 = call i32 (ptr, ...) @printf(ptr @1, i32 %8) + %10 = getelementptr inbounds { ptr }, ptr %0, i32 0, i32 0 + store ptr %i, ptr %10, align 8 + %11 = alloca ptr, align 8 + %12 = call i32 @pthread_create(ptr %11, ptr null, ptr @_thread0, ptr %0) br label %for.inc.l5 for.inc.l5: ; preds = %for.l5 - %7 = load i32, ptr %i, align 4 - %8 = add i32 %7, 1 - store i32 %8, ptr %i, align 4 - %9 = alloca i32, align 4 - store i32 %7, ptr %9, align 4 + %13 = load i32, ptr %i, align 4 + %14 = add i32 %13, 1 + store i32 %14, ptr %i, align 4 + store i32 %13, ptr %1, align 4 br label %for.cond.l5 for.cond.l5: ; preds = %for.inc.l5, %entry.l3 - %10 = load i32, ptr %i, align 4 - %11 = icmp sle i32 %10, 8 - %12 = alloca i1, align 1 - store i1 %11, ptr %12, align 1 - %13 = load i1, ptr %12, align 1 - br i1 %13, label %for.l5, label %for.end.l5 + %15 = load i32, ptr %i, align 4 + %16 = icmp sle i32 %15, 8 + store i1 %16, ptr %2, align 1 + %17 = load i1, ptr %2, align 1 + br i1 %17, label %for.l5, label %for.end.l5 for.end.l5: ; preds = %for.cond.l5 - %14 = alloca i32, align 4 - store i32 1000000, ptr %14, align 4 - %15 = load i32, ptr %14, align 4 - %16 = call i32 @usleep(i32 %15) - %17 = alloca i32, align 4 - store i32 %16, ptr %17, align 4 - %18 = call i32 (ptr, ...) @printf(ptr @3) - %19 = load i32, ptr %result, align 4 - ret i32 %19 + store i32 1000, ptr %3, align 4 + store i32 1000, ptr %4, align 4 + store i32 1000000, ptr %5, align 4 + %18 = load i32, ptr %5, align 4 + %19 = call i32 @usleep(i32 %18) + store i32 %19, ptr %6, align 4 + %20 = call i32 (ptr, ...) @printf(ptr @3) + %21 = load i32, ptr %result, align 4 + ret i32 %21 } declare i32 @printf(ptr, ...) @@ -64,15 +68,21 @@ thread.entry.l7: %1 = getelementptr inbounds { ptr }, ptr %0, i32 0, i32 0 %2 = load ptr, ptr %1, align 8 %3 = load i32, ptr %2, align 4 - %4 = mul i32 100, %3 - %5 = mul i32 %4, 1000 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 %6 = alloca i32, align 4 - store i32 %5, ptr %6, align 4 - %7 = load i32, ptr %6, align 4 - %8 = call i32 @usleep(i32 %7) - %9 = alloca i32, align 4 - store i32 %8, ptr %9, align 4 - %10 = call i32 (ptr, ...) @printf(ptr @2) + %7 = alloca i32, align 4 + %8 = alloca i32, align 4 + store i32 100, ptr %4, align 4 + %9 = mul i32 100, %3 + store i32 100, ptr %5, align 4 + store i32 1000, ptr %6, align 4 + %10 = mul i32 %9, 1000 + store i32 %10, ptr %7, align 4 + %11 = load i32, ptr %7, align 4 + %12 = call i32 @usleep(i32 %11) + store i32 %12, ptr %8, align 4 + %13 = call i32 (ptr, ...) @printf(ptr @2) ret ptr null } diff --git a/test/test-files/generator/threads/success-threads-captures2/ir-code-O2.ll b/test/test-files/generator/threads/success-threads-captures2/ir-code-O2.ll index 1c58e46be..76dc24fac 100644 --- a/test/test-files/generator/threads/success-threads-captures2/ir-code-O2.ll +++ b/test/test-files/generator/threads/success-threads-captures2/ir-code-O2.ll @@ -12,22 +12,22 @@ declare i32 @usleep(i32) local_unnamed_addr define i32 @main() local_unnamed_addr { entry.l3: - %puts = tail call i32 @puts(ptr nonnull @str) %capturedVariable = alloca i32, align 4 - store i32 0, ptr %capturedVariable, align 4 %i = alloca i32, align 4 + %0 = alloca { ptr, ptr }, align 8 + %puts = tail call i32 @puts(ptr nonnull @str) + store i32 0, ptr %capturedVariable, align 4 store i32 1, ptr %i, align 4 + %1 = getelementptr inbounds { ptr, ptr }, ptr %0, i64 0, i32 1 br label %for.l6 for.l6: ; preds = %entry.l3, %for.l6 %storemerge2 = phi i32 [ 1, %entry.l3 ], [ %6, %for.l6 ] - %0 = call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %storemerge2) - %1 = alloca { ptr, ptr }, align 8 - store ptr %capturedVariable, ptr %1, align 8 - %2 = getelementptr inbounds { ptr, ptr }, ptr %1, i64 0, i32 1 - store ptr %i, ptr %2, align 8 + %2 = call i32 (ptr, ...) @printf(ptr nonnull @0, i32 %storemerge2) + store ptr %capturedVariable, ptr %0, align 8 + store ptr %i, ptr %1, align 8 %3 = alloca ptr, align 8 - %4 = call i32 @pthread_create(ptr nonnull %3, ptr null, ptr nonnull @_thread0, ptr nonnull %1) + %4 = call i32 @pthread_create(ptr nonnull %3, ptr null, ptr nonnull @_thread0, ptr nonnull %0) %5 = load i32, ptr %i, align 4 %6 = add i32 %5, 1 store i32 %6, ptr %i, align 4 diff --git a/test/test-files/generator/threads/success-threads-captures2/ir-code.ll b/test/test-files/generator/threads/success-threads-captures2/ir-code.ll index 9c7928000..c1cdffc32 100644 --- a/test/test-files/generator/threads/success-threads-captures2/ir-code.ll +++ b/test/test-files/generator/threads/success-threads-captures2/ir-code.ll @@ -13,52 +13,56 @@ declare i32 @usleep(i32) define i32 @main() { entry.l3: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 - %0 = call i32 (ptr, ...) @printf(ptr @0) %capturedVariable = alloca i32, align 4 - store i32 0, ptr %capturedVariable, align 4 %i = alloca i32, align 4 + %0 = alloca { ptr, ptr }, align 8 + %1 = alloca i32, align 4 + %2 = alloca i1, align 1 + %3 = alloca i32, align 4 + %4 = alloca i32, align 4 + %5 = alloca i32, align 4 + %6 = alloca i32, align 4 + store i32 0, ptr %result, align 4 + %7 = call i32 (ptr, ...) @printf(ptr @0) + store i32 0, ptr %capturedVariable, align 4 store i32 1, ptr %i, align 4 br label %for.cond.l6 for.l6: ; preds = %for.cond.l6 - %1 = load i32, ptr %i, align 4 - %2 = call i32 (ptr, ...) @printf(ptr @1, i32 %1) - %3 = alloca { ptr, ptr }, align 8 - %4 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 0 - store ptr %capturedVariable, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, ptr }, ptr %3, i32 0, i32 1 - store ptr %i, ptr %5, align 8 - %6 = alloca ptr, align 8 - %7 = call i32 @pthread_create(ptr %6, ptr null, ptr @_thread0, ptr %3) + %8 = load i32, ptr %i, align 4 + %9 = call i32 (ptr, ...) @printf(ptr @1, i32 %8) + %10 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 0 + store ptr %capturedVariable, ptr %10, align 8 + %11 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 1 + store ptr %i, ptr %11, align 8 + %12 = alloca ptr, align 8 + %13 = call i32 @pthread_create(ptr %12, ptr null, ptr @_thread0, ptr %0) br label %for.inc.l6 for.inc.l6: ; preds = %for.l6 - %8 = load i32, ptr %i, align 4 - %9 = add i32 %8, 1 - store i32 %9, ptr %i, align 4 - %10 = alloca i32, align 4 - store i32 %8, ptr %10, align 4 + %14 = load i32, ptr %i, align 4 + %15 = add i32 %14, 1 + store i32 %15, ptr %i, align 4 + store i32 %14, ptr %1, align 4 br label %for.cond.l6 for.cond.l6: ; preds = %for.inc.l6, %entry.l3 - %11 = load i32, ptr %i, align 4 - %12 = icmp sle i32 %11, 8 - %13 = alloca i1, align 1 - store i1 %12, ptr %13, align 1 - %14 = load i1, ptr %13, align 1 - br i1 %14, label %for.l6, label %for.end.l6 + %16 = load i32, ptr %i, align 4 + %17 = icmp sle i32 %16, 8 + store i1 %17, ptr %2, align 1 + %18 = load i1, ptr %2, align 1 + br i1 %18, label %for.l6, label %for.end.l6 for.end.l6: ; preds = %for.cond.l6 - %15 = alloca i32, align 4 - store i32 1000000, ptr %15, align 4 - %16 = load i32, ptr %15, align 4 - %17 = call i32 @usleep(i32 %16) - %18 = alloca i32, align 4 - store i32 %17, ptr %18, align 4 - %19 = call i32 (ptr, ...) @printf(ptr @3) - %20 = load i32, ptr %result, align 4 - ret i32 %20 + store i32 1000, ptr %3, align 4 + store i32 1000, ptr %4, align 4 + store i32 1000000, ptr %5, align 4 + %19 = load i32, ptr %5, align 4 + %20 = call i32 @usleep(i32 %19) + store i32 %20, ptr %6, align 4 + %21 = call i32 (ptr, ...) @printf(ptr @3) + %22 = load i32, ptr %result, align 4 + ret i32 %22 } declare i32 @printf(ptr, ...) @@ -70,18 +74,24 @@ thread.entry.l8: %3 = getelementptr inbounds { ptr, ptr }, ptr %0, i32 0, i32 1 %4 = load ptr, ptr %3, align 8 %5 = load i32, ptr %4, align 4 - %6 = mul i32 100, %5 - %7 = mul i32 %6, 1000 + %6 = alloca i32, align 4 + %7 = alloca i32, align 4 %8 = alloca i32, align 4 - store i32 %7, ptr %8, align 4 - %9 = load i32, ptr %8, align 4 - %10 = call i32 @usleep(i32 %9) - %11 = alloca i32, align 4 - store i32 %10, ptr %11, align 4 - %12 = load i32, ptr %2, align 4 - %13 = mul i32 %12, 2 - store volatile i32 %13, ptr %2, align 4 - %14 = call i32 (ptr, ...) @printf(ptr @2) + %9 = alloca i32, align 4 + %10 = alloca i32, align 4 + store i32 100, ptr %6, align 4 + %11 = mul i32 100, %5 + store i32 100, ptr %7, align 4 + store i32 1000, ptr %8, align 4 + %12 = mul i32 %11, 1000 + store i32 %12, ptr %9, align 4 + %13 = load i32, ptr %9, align 4 + %14 = call i32 @usleep(i32 %13) + store i32 %14, ptr %10, align 4 + %15 = load i32, ptr %2, align 4 + %16 = mul i32 %15, 2 + store volatile i32 %16, ptr %2, align 4 + %17 = call i32 (ptr, ...) @printf(ptr @2) ret ptr null } diff --git a/test/test-files/generator/unsafe/success-pointer-cast/ir-code.ll b/test/test-files/generator/unsafe/success-pointer-cast/ir-code.ll index 7ce9b477e..30b2ea95c 100644 --- a/test/test-files/generator/unsafe/success-pointer-cast/ir-code.ll +++ b/test/test-files/generator/unsafe/success-pointer-cast/ir-code.ll @@ -8,17 +8,17 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %l = alloca i64, align 8 - store i64 1234, ptr %l, align 8 %0 = alloca ptr, align 8 - store ptr %l, ptr %0, align 8 %iPtr = alloca ptr, align 8 + %1 = alloca ptr, align 8 + store i32 0, ptr %result, align 4 + store i64 1234, ptr %l, align 8 + store ptr %l, ptr %0, align 8 store ptr null, ptr %iPtr, align 8 - %1 = load ptr, ptr %0, align 8 - %2 = alloca ptr, align 8 - store ptr %1, ptr %2, align 8 - %3 = load ptr, ptr %2, align 8 + %2 = load ptr, ptr %0, align 8 + store ptr %2, ptr %1, align 8 + %3 = load ptr, ptr %1, align 8 store ptr %3, ptr %iPtr, align 8 %4 = load ptr, ptr %iPtr, align 8 %5 = load i32, ptr %4, align 4 diff --git a/test/test-files/generator/variables/success-decl-default-value/ir-code.ll b/test/test-files/generator/variables/success-decl-default-value/ir-code.ll index b021260e2..a813ca5ee 100644 --- a/test/test-files/generator/variables/success-decl-default-value/ir-code.ll +++ b/test/test-files/generator/variables/success-decl-default-value/ir-code.ll @@ -20,49 +20,49 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l11: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %doubleVar = alloca double, align 8 - store double 0.000000e+00, ptr %doubleVar, align 8 - %0 = load double, ptr %doubleVar, align 8 - %1 = call i32 (ptr, ...) @printf(ptr @0, double %0) %intVar = alloca i32, align 4 - store i32 0, ptr %intVar, align 4 - %2 = load i32, ptr %intVar, align 4 - %3 = call i32 (ptr, ...) @printf(ptr @1, i32 %2) %shortVar = alloca i16, align 2 - store i16 0, ptr %shortVar, align 2 - %4 = load i16, ptr %shortVar, align 2 - %5 = sext i16 %4 to i32 - %6 = call i32 (ptr, ...) @printf(ptr @2, i32 %5) %longVar = alloca i64, align 8 - store i64 0, ptr %longVar, align 8 - %7 = load i64, ptr %longVar, align 8 - %8 = call i32 (ptr, ...) @printf(ptr @3, i64 %7) %stringVar = alloca ptr, align 8 - store ptr @4, ptr %stringVar, align 8 - %9 = load ptr, ptr %stringVar, align 8 - %10 = call i32 (ptr, ...) @printf(ptr @5, ptr %9) %byteVar = alloca i8, align 1 - store i8 0, ptr %byteVar, align 1 - %11 = load i8, ptr %byteVar, align 1 - %12 = sext i8 %11 to i32 - %13 = call i32 (ptr, ...) @printf(ptr @6, i32 %12) %charVar = alloca i8, align 1 - store i8 0, ptr %charVar, align 1 - %14 = load i8, ptr %charVar, align 1 - %15 = sext i8 %14 to i32 - %16 = call i32 (ptr, ...) @printf(ptr @7, i32 %15) %boolVar = alloca i1, align 1 + %0 = alloca %_s__NestedStruct__int_string, align 8 + %structArrayVar = alloca [4 x %_s__NestedStruct__int_string], align 8 + store i32 0, ptr %result, align 4 + store double 0.000000e+00, ptr %doubleVar, align 8 + %1 = load double, ptr %doubleVar, align 8 + %2 = call i32 (ptr, ...) @printf(ptr @0, double %1) + store i32 0, ptr %intVar, align 4 + %3 = load i32, ptr %intVar, align 4 + %4 = call i32 (ptr, ...) @printf(ptr @1, i32 %3) + store i16 0, ptr %shortVar, align 2 + %5 = load i16, ptr %shortVar, align 2 + %6 = sext i16 %5 to i32 + %7 = call i32 (ptr, ...) @printf(ptr @2, i32 %6) + store i64 0, ptr %longVar, align 8 + %8 = load i64, ptr %longVar, align 8 + %9 = call i32 (ptr, ...) @printf(ptr @3, i64 %8) + store ptr @4, ptr %stringVar, align 8 + %10 = load ptr, ptr %stringVar, align 8 + %11 = call i32 (ptr, ...) @printf(ptr @5, ptr %10) + store i8 0, ptr %byteVar, align 1 + %12 = load i8, ptr %byteVar, align 1 + %13 = sext i8 %12 to i32 + %14 = call i32 (ptr, ...) @printf(ptr @6, i32 %13) + store i8 0, ptr %charVar, align 1 + %15 = load i8, ptr %charVar, align 1 + %16 = sext i8 %15 to i32 + %17 = call i32 (ptr, ...) @printf(ptr @7, i32 %16) store i1 false, ptr %boolVar, align 1 - %17 = load i1, ptr %boolVar, align 1 - %18 = zext i1 %17 to i32 - %19 = call i32 (ptr, ...) @printf(ptr @8, i32 %18) - %20 = alloca %_s__NestedStruct__int_string, align 8 - %21 = getelementptr inbounds %_s__NestedStruct__int_string, ptr %20, i32 0, i32 0 + %18 = load i1, ptr %boolVar, align 1 + %19 = zext i1 %18 to i32 + %20 = call i32 (ptr, ...) @printf(ptr @8, i32 %19) + %21 = getelementptr inbounds %_s__NestedStruct__int_string, ptr %0, i32 0, i32 0 store i32 0, ptr %21, align 4 - %22 = getelementptr inbounds %_s__NestedStruct__int_string, ptr %20, i32 0, i32 1 + %22 = getelementptr inbounds %_s__NestedStruct__int_string, ptr %0, i32 0, i32 1 store ptr @9, ptr %22, align 8 - %structArrayVar = alloca [4 x %_s__NestedStruct__int_string], align 8 store [4 x %_s__NestedStruct__int_string] [%_s__NestedStruct__int_string { i32 0, ptr @9 }, %_s__NestedStruct__int_string { i32 0, ptr @9 }, %_s__NestedStruct__int_string { i32 0, ptr @9 }, %_s__NestedStruct__int_string { i32 0, ptr @9 }], ptr %structArrayVar, align 8 %23 = getelementptr inbounds [4 x %_s__NestedStruct__int_string], ptr %structArrayVar, i32 0, i32 2 %24 = getelementptr inbounds %_s__NestedStruct__int_string, ptr %23, i32 0, i32 1 diff --git a/test/test-files/generator/variables/success-external-global-var/ir-code.ll b/test/test-files/generator/variables/success-external-global-var/ir-code.ll index e26fb0848..3ff7fe867 100644 --- a/test/test-files/generator/variables/success-external-global-var/ir-code.ll +++ b/test/test-files/generator/variables/success-external-global-var/ir-code.ll @@ -9,11 +9,11 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l3: %result = alloca i32, align 4 + %0 = alloca ptr, align 8 store i32 0, ptr %result, align 4 - %0 = load ptr, ptr @GLOBAL, align 8 - %1 = alloca ptr, align 8 - store ptr %0, ptr %1, align 8 - %2 = load ptr, ptr %1, align 8 + %1 = load ptr, ptr @GLOBAL, align 8 + store ptr %1, ptr %0, align 8 + %2 = load ptr, ptr %0, align 8 %3 = call i32 (ptr, ...) @printf(ptr @0, ptr %2) %4 = load i32, ptr %result, align 4 ret i32 %4 diff --git a/test/test-files/generator/while-loops/success-while-loop-break/ir-code.ll b/test/test-files/generator/while-loops/success-while-loop-break/ir-code.ll index 00d06d540..1405ee0d6 100644 --- a/test/test-files/generator/while-loops/success-while-loop-break/ir-code.ll +++ b/test/test-files/generator/while-loops/success-while-loop-break/ir-code.ll @@ -8,51 +8,51 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %loopCounterOuter = alloca double, align 8 + %0 = alloca i1, align 1 + %1 = alloca i1, align 1 + %loopCounterInner = alloca i16, align 2 + %2 = alloca i1, align 1 + %3 = alloca i16, align 2 + store i32 0, ptr %result, align 4 store double 0.000000e+00, ptr %loopCounterOuter, align 8 br label %while.cond.l3 while.cond.l3: ; preds = %if.end.l4, %entry.l1 - %0 = load double, ptr %loopCounterOuter, align 8 - %1 = fcmp olt double %0, 1.000000e+01 - %2 = alloca i1, align 1 - store i1 %1, ptr %2, align 1 - %3 = load i1, ptr %2, align 1 - br i1 %3, label %while.l3, label %while.end.l3 + %4 = load double, ptr %loopCounterOuter, align 8 + %5 = fcmp olt double %4, 1.000000e+01 + store i1 %5, ptr %0, align 1 + %6 = load i1, ptr %0, align 1 + br i1 %6, label %while.l3, label %while.end.l3 while.l3: ; preds = %while.cond.l3 - %4 = load double, ptr %loopCounterOuter, align 8 - %5 = fcmp olt double %4, 4.000000e+00 - %6 = alloca i1, align 1 - store i1 %5, ptr %6, align 1 - %7 = load i1, ptr %6, align 1 - br i1 %7, label %if.then.l4, label %if.end.l4 + %7 = load double, ptr %loopCounterOuter, align 8 + %8 = fcmp olt double %7, 4.000000e+00 + store i1 %8, ptr %1, align 1 + %9 = load i1, ptr %1, align 1 + br i1 %9, label %if.then.l4, label %if.end.l4 if.then.l4: ; preds = %while.l3 - %loopCounterInner = alloca i16, align 2 store i16 10, ptr %loopCounterInner, align 2 br label %while.cond.l6 while.cond.l6: ; preds = %if.then.l4 - %8 = load i16, ptr %loopCounterInner, align 2 - %9 = sext i16 %8 to i32 - %10 = icmp sgt i32 %9, 0 - %11 = alloca i1, align 1 - store i1 %10, ptr %11, align 1 - %12 = load i1, ptr %11, align 1 - br i1 %12, label %while.l6, label %while.end.l6 + %10 = load i16, ptr %loopCounterInner, align 2 + %11 = sext i16 %10 to i32 + %12 = icmp sgt i32 %11, 0 + store i1 %12, ptr %2, align 1 + %13 = load i1, ptr %2, align 1 + br i1 %13, label %while.l6, label %while.end.l6 while.l6: ; preds = %while.cond.l6 - %13 = load double, ptr %loopCounterOuter, align 8 - %14 = load i16, ptr %loopCounterInner, align 2 - %15 = sext i16 %14 to i32 - %16 = call i32 (ptr, ...) @printf(ptr @0, double %13, i32 %15) - %17 = load i16, ptr %loopCounterInner, align 2 - %18 = sub i16 %17, 1 - store i16 %18, ptr %loopCounterInner, align 2 - %19 = alloca i16, align 2 - store i16 %17, ptr %19, align 2 + %14 = load double, ptr %loopCounterOuter, align 8 + %15 = load i16, ptr %loopCounterInner, align 2 + %16 = sext i16 %15 to i32 + %17 = call i32 (ptr, ...) @printf(ptr @0, double %14, i32 %16) + %18 = load i16, ptr %loopCounterInner, align 2 + %19 = sub i16 %18, 1 + store i16 %19, ptr %loopCounterInner, align 2 + store i16 %18, ptr %3, align 2 br label %while.end.l3 while.end.l6: ; preds = %while.cond.l6 diff --git a/test/test-files/generator/while-loops/success-while-loop-continue/ir-code-O2.ll b/test/test-files/generator/while-loops/success-while-loop-continue/ir-code-O2.ll index cc35d4c68..093e6896e 100644 --- a/test/test-files/generator/while-loops/success-while-loop-continue/ir-code-O2.ll +++ b/test/test-files/generator/while-loops/success-while-loop-continue/ir-code-O2.ll @@ -11,8 +11,8 @@ entry.l1: br label %while.l3 while.l3: ; preds = %entry.l1, %while.cond.l3.backedge - %loopCounterOuter.04 = phi double [ 0.000000e+00, %entry.l1 ], [ %0, %while.cond.l3.backedge ] - %0 = fadd double %loopCounterOuter.04, 1.500000e-01 + %loopCounterOuter.011 = phi double [ 0.000000e+00, %entry.l1 ], [ %0, %while.cond.l3.backedge ] + %0 = fadd double %loopCounterOuter.011, 1.500000e-01 %1 = fcmp olt double %0, 4.000000e+00 br i1 %1, label %while.cond.l3.backedge.loopexit, label %while.cond.l3.backedge diff --git a/test/test-files/generator/while-loops/success-while-loop-continue/ir-code.ll b/test/test-files/generator/while-loops/success-while-loop-continue/ir-code.ll index 88f6d5bd1..e02520015 100644 --- a/test/test-files/generator/while-loops/success-while-loop-continue/ir-code.ll +++ b/test/test-files/generator/while-loops/success-while-loop-continue/ir-code.ll @@ -8,60 +8,60 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %loopCounterOuter = alloca double, align 8 + %0 = alloca i1, align 1 + %1 = alloca i1, align 1 + %loopCounterInner = alloca i16, align 2 + %2 = alloca i1, align 1 + %3 = alloca i16, align 2 + %4 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store double 0.000000e+00, ptr %loopCounterOuter, align 8 br label %while.cond.l3 while.cond.l3: ; preds = %if.end.l5, %if.then.l10, %entry.l1 - %0 = load double, ptr %loopCounterOuter, align 8 - %1 = fcmp olt double %0, 1.000000e+01 - %2 = alloca i1, align 1 - store i1 %1, ptr %2, align 1 - %3 = load i1, ptr %2, align 1 - br i1 %3, label %while.l3, label %while.end.l3 + %5 = load double, ptr %loopCounterOuter, align 8 + %6 = fcmp olt double %5, 1.000000e+01 + store i1 %6, ptr %0, align 1 + %7 = load i1, ptr %0, align 1 + br i1 %7, label %while.l3, label %while.end.l3 while.l3: ; preds = %while.cond.l3 - %4 = load double, ptr %loopCounterOuter, align 8 - %5 = fadd double %4, 1.500000e-01 - store double %5, ptr %loopCounterOuter, align 8 - %6 = load double, ptr %loopCounterOuter, align 8 - %7 = fcmp olt double %6, 4.000000e+00 - %8 = alloca i1, align 1 - store i1 %7, ptr %8, align 1 - %9 = load i1, ptr %8, align 1 - br i1 %9, label %if.then.l5, label %if.end.l5 + %8 = load double, ptr %loopCounterOuter, align 8 + %9 = fadd double %8, 1.500000e-01 + store double %9, ptr %loopCounterOuter, align 8 + %10 = load double, ptr %loopCounterOuter, align 8 + %11 = fcmp olt double %10, 4.000000e+00 + store i1 %11, ptr %1, align 1 + %12 = load i1, ptr %1, align 1 + br i1 %12, label %if.then.l5, label %if.end.l5 if.then.l5: ; preds = %while.l3 - %loopCounterInner = alloca i16, align 2 store i16 10, ptr %loopCounterInner, align 2 br label %while.cond.l7 while.cond.l7: ; preds = %if.end.l10, %if.then.l5 - %10 = load i16, ptr %loopCounterInner, align 2 - %11 = sext i16 %10 to i32 - %12 = icmp sgt i32 %11, 0 - %13 = alloca i1, align 1 - store i1 %12, ptr %13, align 1 - %14 = load i1, ptr %13, align 1 - br i1 %14, label %while.l7, label %while.end.l7 + %13 = load i16, ptr %loopCounterInner, align 2 + %14 = sext i16 %13 to i32 + %15 = icmp sgt i32 %14, 0 + store i1 %15, ptr %2, align 1 + %16 = load i1, ptr %2, align 1 + br i1 %16, label %while.l7, label %while.end.l7 while.l7: ; preds = %while.cond.l7 - %15 = load double, ptr %loopCounterOuter, align 8 - %16 = load i16, ptr %loopCounterInner, align 2 - %17 = sext i16 %16 to i32 - %18 = call i32 (ptr, ...) @printf(ptr @0, double %15, i32 %17) - %19 = load i16, ptr %loopCounterInner, align 2 - %20 = sub i16 %19, 1 - store i16 %20, ptr %loopCounterInner, align 2 - %21 = alloca i16, align 2 - store i16 %19, ptr %21, align 2 - %22 = load i16, ptr %loopCounterInner, align 2 - %23 = sext i16 %22 to i32 - %24 = icmp eq i32 %23, 5 - %25 = alloca i1, align 1 - store i1 %24, ptr %25, align 1 - %26 = load i1, ptr %25, align 1 + %17 = load double, ptr %loopCounterOuter, align 8 + %18 = load i16, ptr %loopCounterInner, align 2 + %19 = sext i16 %18 to i32 + %20 = call i32 (ptr, ...) @printf(ptr @0, double %17, i32 %19) + %21 = load i16, ptr %loopCounterInner, align 2 + %22 = sub i16 %21, 1 + store i16 %22, ptr %loopCounterInner, align 2 + store i16 %21, ptr %3, align 2 + %23 = load i16, ptr %loopCounterInner, align 2 + %24 = sext i16 %23 to i32 + %25 = icmp eq i32 %24, 5 + store i1 %25, ptr %4, align 1 + %26 = load i1, ptr %4, align 1 br i1 %26, label %if.then.l10, label %if.end.l10 if.then.l10: ; preds = %while.l7 diff --git a/test/test-files/generator/while-loops/success-while-loop/ir-code.ll b/test/test-files/generator/while-loops/success-while-loop/ir-code.ll index 7fa14ffee..05259587c 100644 --- a/test/test-files/generator/while-loops/success-while-loop/ir-code.ll +++ b/test/test-files/generator/while-loops/success-while-loop/ir-code.ll @@ -8,17 +8,17 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() { entry.l1: %result = alloca i32, align 4 - store i32 0, ptr %result, align 4 %i = alloca i32, align 4 + %0 = alloca i1, align 1 + store i32 0, ptr %result, align 4 store i32 0, ptr %i, align 4 br label %while.cond.l3 while.cond.l3: ; preds = %while.l3, %entry.l1 - %0 = load i32, ptr %i, align 4 - %1 = icmp slt i32 %0, 10 - %2 = alloca i1, align 1 - store i1 %1, ptr %2, align 1 - %3 = load i1, ptr %2, align 1 + %1 = load i32, ptr %i, align 4 + %2 = icmp slt i32 %1, 10 + store i1 %2, ptr %0, align 1 + %3 = load i1, ptr %0, align 1 br i1 %3, label %while.l3, label %while.end.l3 while.l3: ; preds = %while.cond.l3 diff --git a/test/test-files/std/runtime/string-operators/ir-code-O2.ll b/test/test-files/std/runtime/string-operators/ir-code-O2.ll index 0b5041e80..8c78a849c 100644 --- a/test/test-files/std/runtime/string-operators/ir-code-O2.ll +++ b/test/test-files/std/runtime/string-operators/ir-code-O2.ll @@ -3,24 +3,7 @@ source_filename = "source.spice" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-w64-windows-gnu" -%_s__String__charptr_long_long.0 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.1 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.4 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.5 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.7 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.8 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.11 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.12 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.14 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.15 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.18 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.19 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.21 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.22 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.24 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.25 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.27 = type { ptr, i64, i64 } -%_s__String__charptr_long_long.28 = type { ptr, i64, i64 } +%_s__String__charptr_long_long = type { ptr, i64, i64 } @0 = private unnamed_addr constant [7 x i8] c"World!\00", align 1 @1 = private unnamed_addr constant [7 x i8] c"Hello \00", align 1 @@ -36,146 +19,87 @@ target triple = "x86_64-w64-windows-gnu" define i32 @main() local_unnamed_addr { entry.l3: - %0 = alloca %_s__String__charptr_long_long.0, align 8 + %0 = alloca %_s__String__charptr_long_long, align 8 + %1 = alloca %_s__String__charptr_long_long, align 8 + %2 = alloca %_s__String__charptr_long_long, align 8 + %3 = alloca %_s__String__charptr_long_long, align 8 + %4 = alloca %_s__String__charptr_long_long, align 8 + %5 = alloca %_s__String__charptr_long_long, align 8 + %6 = alloca %_s__String__charptr_long_long, align 8 + %7 = alloca %_s__String__charptr_long_long, align 8 + %8 = alloca %_s__String__charptr_long_long, align 8 + %9 = alloca %_s__String__charptr_long_long, align 8 + %10 = alloca %_s__String__charptr_long_long, align 8 call void @_mp__String__ctor__string_string(ptr nonnull %0, ptr nonnull @1, ptr nonnull @0) - %1 = alloca ptr, align 8 - store ptr %0, ptr %1, align 8 - %2 = call ptr @_mf__String__getRaw(ptr nonnull %1) - %.unpack = load ptr, ptr %2, align 8 - %3 = insertvalue %_s__String__charptr_long_long.1 undef, ptr %.unpack, 0 - %.elt6 = getelementptr inbounds %_s__String__charptr_long_long.1, ptr %2, i64 0, i32 1 - %.unpack7 = load i64, ptr %.elt6, align 8 - %4 = insertvalue %_s__String__charptr_long_long.1 %3, i64 %.unpack7, 1 - %.elt8 = getelementptr inbounds %_s__String__charptr_long_long.1, ptr %2, i64 0, i32 2 - %.unpack9 = load i64, ptr %.elt8, align 8 - %5 = insertvalue %_s__String__charptr_long_long.1 %4, i64 %.unpack9, 2 - %6 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.1 %5) - %7 = alloca %_s__String__charptr_long_long.4, align 8 - call void @_mp__String__ctor__string_string(ptr nonnull %7, ptr nonnull @1, ptr nonnull @0) - %8 = alloca ptr, align 8 - store ptr %7, ptr %8, align 8 - %9 = call ptr @_mf__String__getRaw(ptr nonnull %8) - %.unpack10 = load ptr, ptr %9, align 8 - %10 = insertvalue %_s__String__charptr_long_long.5 undef, ptr %.unpack10, 0 - %.elt11 = getelementptr inbounds %_s__String__charptr_long_long.5, ptr %9, i64 0, i32 1 - %.unpack12 = load i64, ptr %.elt11, align 8 - %11 = insertvalue %_s__String__charptr_long_long.5 %10, i64 %.unpack12, 1 - %.elt13 = getelementptr inbounds %_s__String__charptr_long_long.5, ptr %9, i64 0, i32 2 - %.unpack14 = load i64, ptr %.elt13, align 8 - %12 = insertvalue %_s__String__charptr_long_long.5 %11, i64 %.unpack14, 2 - %13 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.5 %12) - %14 = alloca %_s__String__charptr_long_long.7, align 8 - call void @_mp__String__ctor__string(ptr nonnull %14, ptr nonnull @9) - call void @_mp__String__opMul__short(ptr nonnull %14, i16 4) - %15 = alloca ptr, align 8 - store ptr %14, ptr %15, align 8 - %16 = call ptr @_mf__String__getRaw(ptr nonnull %15) - %.unpack15 = load ptr, ptr %16, align 8 - %17 = insertvalue %_s__String__charptr_long_long.8 undef, ptr %.unpack15, 0 - %.elt16 = getelementptr inbounds %_s__String__charptr_long_long.8, ptr %16, i64 0, i32 1 - %.unpack17 = load i64, ptr %.elt16, align 8 - %18 = insertvalue %_s__String__charptr_long_long.8 %17, i64 %.unpack17, 1 - %.elt18 = getelementptr inbounds %_s__String__charptr_long_long.8, ptr %16, i64 0, i32 2 - %.unpack19 = load i64, ptr %.elt18, align 8 - %19 = insertvalue %_s__String__charptr_long_long.8 %18, i64 %.unpack19, 2 - %20 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.8 %19) - %21 = alloca %_s__String__charptr_long_long.11, align 8 - call void @_mp__String__ctor__string(ptr nonnull %21, ptr nonnull @1) - call void @_mp__String__opMul__int(ptr nonnull %21, i32 5) - %22 = alloca ptr, align 8 - store ptr %21, ptr %22, align 8 - %23 = call ptr @_mf__String__getRaw(ptr nonnull %22) - %.unpack20 = load ptr, ptr %23, align 8 - %24 = insertvalue %_s__String__charptr_long_long.12 undef, ptr %.unpack20, 0 - %.elt21 = getelementptr inbounds %_s__String__charptr_long_long.12, ptr %23, i64 0, i32 1 - %.unpack22 = load i64, ptr %.elt21, align 8 - %25 = insertvalue %_s__String__charptr_long_long.12 %24, i64 %.unpack22, 1 - %.elt23 = getelementptr inbounds %_s__String__charptr_long_long.12, ptr %23, i64 0, i32 2 - %.unpack24 = load i64, ptr %.elt23, align 8 - %26 = insertvalue %_s__String__charptr_long_long.12 %25, i64 %.unpack24, 2 - %27 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.12 %26) - %28 = alloca %_s__String__charptr_long_long.14, align 8 - call void @_mp__String__ctor__char(ptr nonnull %28, i8 97) - call void @_mp__String__opMul__int(ptr nonnull %28, i32 20) - %29 = alloca ptr, align 8 - store ptr %28, ptr %29, align 8 - %30 = call ptr @_mf__String__getRaw(ptr nonnull %29) - %.unpack25 = load ptr, ptr %30, align 8 - %31 = insertvalue %_s__String__charptr_long_long.15 undef, ptr %.unpack25, 0 - %.elt26 = getelementptr inbounds %_s__String__charptr_long_long.15, ptr %30, i64 0, i32 1 - %.unpack27 = load i64, ptr %.elt26, align 8 - %32 = insertvalue %_s__String__charptr_long_long.15 %31, i64 %.unpack27, 1 - %.elt28 = getelementptr inbounds %_s__String__charptr_long_long.15, ptr %30, i64 0, i32 2 - %.unpack29 = load i64, ptr %.elt28, align 8 - %33 = insertvalue %_s__String__charptr_long_long.15 %32, i64 %.unpack29, 2 - %34 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.15 %33) - %35 = alloca %_s__String__charptr_long_long.18, align 8 - call void @_mp__String__ctor__char(ptr nonnull %35, i8 99) - call void @_mp__String__opMul__int(ptr nonnull %35, i32 2) - call void @_mp__String__opMul__int(ptr nonnull %35, i32 7) - %36 = alloca ptr, align 8 - store ptr %35, ptr %36, align 8 - %37 = call ptr @_mf__String__getRaw(ptr nonnull %36) - %.unpack30 = load ptr, ptr %37, align 8 - %38 = insertvalue %_s__String__charptr_long_long.19 undef, ptr %.unpack30, 0 - %.elt31 = getelementptr inbounds %_s__String__charptr_long_long.19, ptr %37, i64 0, i32 1 - %.unpack32 = load i64, ptr %.elt31, align 8 - %39 = insertvalue %_s__String__charptr_long_long.19 %38, i64 %.unpack32, 1 - %.elt33 = getelementptr inbounds %_s__String__charptr_long_long.19, ptr %37, i64 0, i32 2 - %.unpack34 = load i64, ptr %.elt33, align 8 - %40 = insertvalue %_s__String__charptr_long_long.19 %39, i64 %.unpack34, 2 - %41 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.19 %40) - %42 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 zext (i1 icmp eq (ptr @3, ptr @4) to i32)) - %43 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 zext (i1 icmp eq (ptr @7, ptr @5) to i32)) - %44 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 1) - %45 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 zext (i1 icmp ne (ptr @3, ptr @4) to i32)) - %46 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 zext (i1 icmp ne (ptr @7, ptr @5) to i32)) - %47 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 0) - %s4 = alloca ptr, align 8 - %48 = alloca %_s__String__charptr_long_long.21, align 8 - call void @_mp__String__ctor__string(ptr nonnull %48, ptr nonnull @7) - call void @_mp__String__append__char(ptr nonnull %48, i8 108) - store ptr %48, ptr %s4, align 8 - %49 = call ptr @_mf__String__getRaw(ptr nonnull %s4) - %.unpack35 = load ptr, ptr %49, align 8 - %50 = insertvalue %_s__String__charptr_long_long.22 undef, ptr %.unpack35, 0 - %.elt36 = getelementptr inbounds %_s__String__charptr_long_long.22, ptr %49, i64 0, i32 1 - %.unpack37 = load i64, ptr %.elt36, align 8 - %51 = insertvalue %_s__String__charptr_long_long.22 %50, i64 %.unpack37, 1 - %.elt38 = getelementptr inbounds %_s__String__charptr_long_long.22, ptr %49, i64 0, i32 2 - %.unpack39 = load i64, ptr %.elt38, align 8 - %52 = insertvalue %_s__String__charptr_long_long.22 %51, i64 %.unpack39, 2 - %53 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.22 %52) - %s5 = alloca ptr, align 8 - %54 = alloca %_s__String__charptr_long_long.24, align 8 - call void @_mp__String__ctor__string(ptr nonnull %54, ptr nonnull @9) - call void @_mp__String__append__string(ptr nonnull %54, ptr nonnull @8) - store ptr %54, ptr %s5, align 8 - %55 = call ptr @_mf__String__getRaw(ptr nonnull %s5) - %.unpack40 = load ptr, ptr %55, align 8 - %56 = insertvalue %_s__String__charptr_long_long.25 undef, ptr %.unpack40, 0 - %.elt41 = getelementptr inbounds %_s__String__charptr_long_long.25, ptr %55, i64 0, i32 1 - %.unpack42 = load i64, ptr %.elt41, align 8 - %57 = insertvalue %_s__String__charptr_long_long.25 %56, i64 %.unpack42, 1 - %.elt43 = getelementptr inbounds %_s__String__charptr_long_long.25, ptr %55, i64 0, i32 2 - %.unpack44 = load i64, ptr %.elt43, align 8 - %58 = insertvalue %_s__String__charptr_long_long.25 %57, i64 %.unpack44, 2 - %59 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.25 %58) - %s6 = alloca ptr, align 8 - %60 = alloca %_s__String__charptr_long_long.27, align 8 - call void @_mp__String__ctor__string(ptr nonnull %60, ptr nonnull @9) - call void @_mp__String__opMul__int(ptr nonnull %60, i32 3) - store ptr %60, ptr %s6, align 8 - %61 = call ptr @_mf__String__getRaw(ptr nonnull %s6) - %.unpack45 = load ptr, ptr %61, align 8 - %62 = insertvalue %_s__String__charptr_long_long.28 undef, ptr %.unpack45, 0 - %.elt46 = getelementptr inbounds %_s__String__charptr_long_long.28, ptr %61, i64 0, i32 1 - %.unpack47 = load i64, ptr %.elt46, align 8 - %63 = insertvalue %_s__String__charptr_long_long.28 %62, i64 %.unpack47, 1 - %.elt48 = getelementptr inbounds %_s__String__charptr_long_long.28, ptr %61, i64 0, i32 2 - %.unpack49 = load i64, ptr %.elt48, align 8 - %64 = insertvalue %_s__String__charptr_long_long.28 %63, i64 %.unpack49, 2 - %65 = call i32 (ptr, ...) @printf(ptr nonnull @10, %_s__String__charptr_long_long.28 %64) + %.fca.0.load64 = load ptr, ptr %0, align 8 + %.fca.1.gep66 = getelementptr inbounds %_s__String__charptr_long_long, ptr %0, i64 0, i32 1 + %.fca.1.load67 = load i64, ptr %.fca.1.gep66, align 8 + %.fca.2.gep69 = getelementptr inbounds %_s__String__charptr_long_long, ptr %0, i64 0, i32 2 + %.fca.2.load70 = load i64, ptr %.fca.2.gep69, align 8 + store ptr %.fca.0.load64, ptr %1, align 8 + %.fca.1.gep60 = getelementptr inbounds %_s__String__charptr_long_long, ptr %1, i64 0, i32 1 + store i64 %.fca.1.load67, ptr %.fca.1.gep60, align 8 + %.fca.2.gep62 = getelementptr inbounds %_s__String__charptr_long_long, ptr %1, i64 0, i32 2 + store i64 %.fca.2.load70, ptr %.fca.2.gep62, align 8 + %11 = call ptr @_mf__String__getRaw(ptr nonnull %1) + %12 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %11) + call void @_mp__String__ctor__string_string(ptr nonnull %2, ptr nonnull @1, ptr nonnull @0) + %.fca.0.load49 = load ptr, ptr %2, align 8 + %.fca.1.gep51 = getelementptr inbounds %_s__String__charptr_long_long, ptr %2, i64 0, i32 1 + %.fca.1.load52 = load i64, ptr %.fca.1.gep51, align 8 + %.fca.2.gep54 = getelementptr inbounds %_s__String__charptr_long_long, ptr %2, i64 0, i32 2 + %.fca.2.load55 = load i64, ptr %.fca.2.gep54, align 8 + store ptr %.fca.0.load49, ptr %3, align 8 + %.fca.1.gep46 = getelementptr inbounds %_s__String__charptr_long_long, ptr %3, i64 0, i32 1 + store i64 %.fca.1.load52, ptr %.fca.1.gep46, align 8 + %.fca.2.gep47 = getelementptr inbounds %_s__String__charptr_long_long, ptr %3, i64 0, i32 2 + store i64 %.fca.2.load55, ptr %.fca.2.gep47, align 8 + %13 = call ptr @_mf__String__getRaw(ptr nonnull %3) + %14 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %13) + call void @_mp__String__ctor__string(ptr nonnull %4, ptr nonnull @9) + call void @_mp__String__opMul__short(ptr nonnull %4, i16 4) + %15 = call ptr @_mf__String__getRaw(ptr nonnull %4) + %16 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %15) + call void @_mp__String__ctor__string(ptr nonnull %5, ptr nonnull @1) + call void @_mp__String__opMul__int(ptr nonnull %5, i32 5) + %17 = call ptr @_mf__String__getRaw(ptr nonnull %5) + %18 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %17) + call void @_mp__String__ctor__char(ptr nonnull %6, i8 97) + call void @_mp__String__opMul__int(ptr nonnull %6, i32 20) + %19 = call ptr @_mf__String__getRaw(ptr nonnull %6) + %20 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %19) + call void @_mp__String__ctor__char(ptr nonnull %7, i8 99) + call void @_mp__String__opMul__int(ptr nonnull %7, i32 2) + call void @_mp__String__opMul__int(ptr nonnull %7, i32 7) + %21 = call ptr @_mf__String__getRaw(ptr nonnull %7) + %22 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %21) + %23 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 zext (i1 icmp eq (ptr @3, ptr @4) to i32)) + %24 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 zext (i1 icmp eq (ptr @7, ptr @5) to i32)) + %25 = call i32 (ptr, ...) @printf(ptr nonnull @2, i32 1) + %26 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 zext (i1 icmp ne (ptr @3, ptr @4) to i32)) + %27 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 zext (i1 icmp ne (ptr @7, ptr @5) to i32)) + %28 = call i32 (ptr, ...) @printf(ptr nonnull @6, i32 0) + call void @_mp__String__ctor__string(ptr nonnull %8, ptr nonnull @7) + call void @_mp__String__append__char(ptr nonnull %8, i8 108) + %29 = call ptr @_mf__String__getRaw(ptr nonnull %8) + %30 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %29) + call void @_mp__String__ctor__string(ptr nonnull %9, ptr nonnull @9) + call void @_mp__String__append__string(ptr nonnull %9, ptr nonnull @8) + %31 = call ptr @_mf__String__getRaw(ptr nonnull %9) + %32 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %31) + call void @_mp__String__ctor__string(ptr nonnull %10, ptr nonnull @9) + call void @_mp__String__opMul__int(ptr nonnull %10, i32 3) + %33 = call ptr @_mf__String__getRaw(ptr nonnull %10) + %34 = call i32 (ptr, ...) @printf(ptr nonnull @10, ptr %33) + call void @_mp__String__dtor(ptr nonnull %5) + call void @_mp__String__dtor(ptr nonnull %6) + call void @_mp__String__dtor(ptr nonnull %7) + call void @_mp__String__dtor(ptr nonnull %8) + call void @_mp__String__dtor(ptr nonnull %9) + call void @_mp__String__dtor(ptr nonnull %10) + call void @_mp__String__dtor(ptr nonnull %0) + call void @_mp__String__dtor(ptr nonnull %2) + call void @_mp__String__dtor(ptr nonnull %4) ret i32 0 } @@ -198,4 +122,6 @@ declare void @_mp__String__append__char(ptr, i8) local_unnamed_addr declare void @_mp__String__append__string(ptr, ptr) local_unnamed_addr +declare void @_mp__String__dtor(ptr) local_unnamed_addr + attributes #0 = { nofree nounwind }