GCC Code Coverage Report

Directory: ../
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 98.8% 497 / 17 / 520
Functions: 95.0% 19 / 0 / 20
Branches: 60.0% 557 / 36 / 964
src/irgenerator/GenExpressions.cpp
Line Branch Exec Source
1 // Copyright (c) 2021-2026 ChilliBits. All rights reserved.
2
3 #include "IRGenerator.h"
4
5 #include <ast/ASTNodes.h>
6
7 #include <llvm/IR/Module.h>
8
9 namespace spice::compiler {
10
11 79287 std::any IRGenerator::visitAssignExpr(const AssignExprNode *node) {
12 79287 diGenerator.setSourceLocation(node);
13
14 // Visit ternary expression
15
2/2
✓ Branch 3 → 4 taken 72695 times.
✓ Branch 3 → 5 taken 6592 times.
 79287 if (node->ternaryExpr)
16 72695 return visit(node->ternaryExpr);
17
18 // Assign or compound assign operation
19
1/2
✓ Branch 5 → 6 taken 6592 times.
✗ Branch 5 → 60 not taken.
 6592 if (node->op != AssignExprNode::AssignOp::OP_NONE) {
20 6592 const PrefixUnaryExprNode *lhsNode = node->lhs;
21 6592 const AssignExprNode *rhsNode = node->rhs;
22
23 // Normal assignment
24
2/2
✓ Branch 6 → 7 taken 5774 times.
✓ Branch 6 → 11 taken 818 times.
 6592 if (node->op == AssignExprNode::AssignOp::OP_ASSIGN)
25
2/4
✓ Branch 7 → 8 taken 5774 times.
✗ Branch 7 → 69 not taken.
✓ Branch 8 → 9 taken 5774 times.
✗ Branch 8 → 69 not taken.
 5774 return doAssignment(lhsNode, rhsNode, node);
26
27 // Compound assignment
28 // Get symbol types of left and right side
29
1/2
✓ Branch 11 → 12 taken 818 times.
✗ Branch 11 → 85 not taken.
 818 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
30
1/2
✓ Branch 12 → 13 taken 818 times.
✗ Branch 12 → 85 not taken.
 818 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
31
32 // Retrieve rhs
33
2/4
✓ Branch 13 → 14 taken 818 times.
✗ Branch 13 → 72 not taken.
✓ Branch 14 → 15 taken 818 times.
✗ Branch 14 → 70 not taken.
 818 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
34 // Retrieve lhs
35
2/4
✓ Branch 16 → 17 taken 818 times.
✗ Branch 16 → 75 not taken.
✓ Branch 17 → 18 taken 818 times.
✗ Branch 17 → 73 not taken.
 818 auto lhs = std::any_cast<LLVMExprResult>(visit(lhsNode));
36
37 818 LLVMExprResult result;
38
10/11
✓ Branch 19 → 20 taken 269 times.
✓ Branch 19 → 22 taken 48 times.
✓ Branch 19 → 24 taken 49 times.
✓ Branch 19 → 26 taken 54 times.
✓ Branch 19 → 28 taken 16 times.
✓ Branch 19 → 30 taken 11 times.
✓ Branch 19 → 32 taken 12 times.
✓ Branch 19 → 34 taken 11 times.
✓ Branch 19 → 36 taken 11 times.
✓ Branch 19 → 38 taken 337 times.
✗ Branch 19 → 40 not taken.
 818 switch (node->op) {
39 269 case AssignExprNode::AssignOp::OP_PLUS_EQUAL:
40
1/2
✓ Branch 20 → 21 taken 269 times.
✗ Branch 20 → 85 not taken.
 269 result = conversionManager.getPlusEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
41 269 break;
42 48 case AssignExprNode::AssignOp::OP_MINUS_EQUAL:
43
1/2
✓ Branch 22 → 23 taken 48 times.
✗ Branch 22 → 85 not taken.
 48 result = conversionManager.getMinusEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
44 48 break;
45 49 case AssignExprNode::AssignOp::OP_MUL_EQUAL:
46
1/2
✓ Branch 24 → 25 taken 49 times.
✗ Branch 24 → 85 not taken.
 49 result = conversionManager.getMulEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
47 49 break;
48 54 case AssignExprNode::AssignOp::OP_DIV_EQUAL:
49
1/2
✓ Branch 26 → 27 taken 54 times.
✗ Branch 26 → 85 not taken.
 54 result = conversionManager.getDivEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
50 54 break;
51 16 case AssignExprNode::AssignOp::OP_REM_EQUAL:
52
1/2
✓ Branch 28 → 29 taken 16 times.
✗ Branch 28 → 85 not taken.
 16 result = conversionManager.getRemEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
53 16 break;
54 11 case AssignExprNode::AssignOp::OP_SHL_EQUAL:
55
1/2
✓ Branch 30 → 31 taken 11 times.
✗ Branch 30 → 85 not taken.
 11 result = conversionManager.getSHLEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
56 11 break;
57 12 case AssignExprNode::AssignOp::OP_SHR_EQUAL:
58
1/2
✓ Branch 32 → 33 taken 12 times.
✗ Branch 32 → 85 not taken.
 12 result = conversionManager.getSHREqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
59 12 break;
60 11 case AssignExprNode::AssignOp::OP_AND_EQUAL:
61
1/2
✓ Branch 34 → 35 taken 11 times.
✗ Branch 34 → 85 not taken.
 11 result = conversionManager.getAndEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
62 11 break;
63 11 case AssignExprNode::AssignOp::OP_OR_EQUAL:
64
1/2
✓ Branch 36 → 37 taken 11 times.
✗ Branch 36 → 85 not taken.
 11 result = conversionManager.getOrEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
65 11 break;
66 337 case AssignExprNode::AssignOp::OP_XOR_EQUAL:
67
1/2
✓ Branch 38 → 39 taken 337 times.
✗ Branch 38 → 85 not taken.
 337 result = conversionManager.getXorEqualInst(node, lhs, lhsSTy, rhs, rhsSTy);
68 337 break;
69 − default: // GCOV_EXCL_LINE
70 − throw CompilerError(UNHANDLED_BRANCH, "Assign op fall-through"); // GCOV_EXCL_LINE
71 }
72
73
1/2
✗ Branch 48 → 49 not taken.
✓ Branch 48 → 51 taken 818 times.
 818 if (result.ptr) { // The operation allocated more memory
74 ✗ if (lhs.entry)
75 ✗ lhs.entry->updateAddress(result.ptr);
76
2/2
✓ Branch 51 → 52 taken 675 times.
✓ Branch 51 → 57 taken 143 times.
 818 } else if (result.value) { // The operation only updated the value
77 // Store the result
78 675 lhs.value = result.value;
79
5/6
✓ Branch 52 → 53 taken 406 times.
✓ Branch 52 → 55 taken 269 times.
✓ Branch 53 → 54 taken 1 time.
✓ Branch 53 → 55 taken 405 times.
✓ Branch 56 → 57 taken 675 times.
✗ Branch 56 → 85 not taken.
 675 insertStore(lhs.value, lhs.ptr, lhs.entry && lhs.entry->isVolatile);
80 }
81
1/2
✓ Branch 57 → 58 taken 818 times.
✗ Branch 57 → 85 not taken.
 818 return lhs;
82 }
83
84 // This is a fallthrough case -> throw an error
85 − throw CompilerError(UNHANDLED_BRANCH, "AssignStmt fall-through"); // GCOV_EXCL_LINE
86 }
87
88 72996 std::any IRGenerator::visitTernaryExpr(const TernaryExprNode *node) {
89 72996 diGenerator.setSourceLocation(node);
90
91 // Check if only one operand is present -> loop through
92
2/2
✓ Branch 3 → 4 taken 72498 times.
✓ Branch 3 → 5 taken 498 times.
 72996 if (!node->falseExpr)
93 72498 return visit(node->condition);
94
95 // It is a ternary
96 // Retrieve the condition value
97 498 llvm::Value *condValue = resolveValue(node->condition);
98
2/2
✓ Branch 6 → 7 taken 1 time.
✓ Branch 6 → 8 taken 497 times.
 498 const LogicalOrExprNode *trueNode = node->isShortened ? node->condition : node->trueExpr;
99 498 const LogicalOrExprNode *falseNode = node->falseExpr;
100
101 498 llvm::Value *resultValue = nullptr;
102 498 llvm::Value *resultPtr = nullptr;
103 498 SymbolTableEntry *anonymousSymbol = nullptr;
104
6/6
✓ Branch 10 → 11 taken 127 times.
✓ Branch 10 → 14 taken 371 times.
✓ Branch 12 → 13 taken 126 times.
✓ Branch 12 → 14 taken 1 time.
✓ Branch 15 → 16 taken 126 times.
✓ Branch 15 → 21 taken 372 times.
 498 if (trueNode->hasCompileTimeValue() && falseNode->hasCompileTimeValue()) {
105 // If both are constants, we can simply emit a selection instruction
106 126 llvm::Value *trueValue = resolveValue(trueNode);
107 126 llvm::Value *falseValue = resolveValue(falseNode);
108
2/4
✓ Branch 18 → 19 taken 126 times.
✗ Branch 18 → 147 not taken.
✓ Branch 19 → 20 taken 126 times.
✗ Branch 19 → 147 not taken.
 126 resultValue = builder.CreateSelect(condValue, trueValue, falseValue);
109 } else {
110 // We have at least one non-constant value, use branching to not perform both sides
111
1/2
✓ Branch 21 → 22 taken 372 times.
✗ Branch 21 → 206 not taken.
 372 const std::string codeLoc = node->codeLoc.toPrettyLineAndColumn();
112
2/4
✓ Branch 22 → 23 taken 372 times.
✗ Branch 22 → 150 not taken.
✓ Branch 23 → 24 taken 372 times.
✗ Branch 23 → 148 not taken.
 372 llvm::BasicBlock *condTrue = createBlock("cond.true." + codeLoc);
113
2/4
✓ Branch 25 → 26 taken 372 times.
✗ Branch 25 → 153 not taken.
✓ Branch 26 → 27 taken 372 times.
✗ Branch 26 → 151 not taken.
 372 llvm::BasicBlock *condFalse = createBlock("cond.false." + codeLoc);
114
2/4
✓ Branch 28 → 29 taken 372 times.
✗ Branch 28 → 156 not taken.
✓ Branch 29 → 30 taken 372 times.
✗ Branch 29 → 154 not taken.
 372 llvm::BasicBlock *condExit = createBlock("cond.exit." + codeLoc);
115
116 // Jump from original block to true or false block, depending on condition
117
1/2
✓ Branch 31 → 32 taken 372 times.
✗ Branch 31 → 204 not taken.
 372 insertCondJump(condValue, condTrue, condFalse);
118
119 // Fill true block
120
1/2
✓ Branch 32 → 33 taken 372 times.
✗ Branch 32 → 204 not taken.
 372 switchToBlock(condTrue);
121
1/2
✓ Branch 33 → 34 taken 372 times.
✗ Branch 33 → 204 not taken.
 372 const QualType &resultType = node->getEvaluatedSymbolType(manIdx);
122 372 llvm::Value *trueValue = nullptr;
123 372 llvm::Value *truePtr = nullptr;
124
7/8
✓ Branch 34 → 35 taken 364 times.
✓ Branch 34 → 37 taken 8 times.
✓ Branch 35 → 36 taken 364 times.
✗ Branch 35 → 204 not taken.
✓ Branch 36 → 37 taken 9 times.
✓ Branch 36 → 38 taken 355 times.
✓ Branch 39 → 40 taken 17 times.
✓ Branch 39 → 42 taken 355 times.
 372 if (node->falseSideCallsCopyCtor || resultType.isRef()) { // both sides or only the false side needs copy ctor call
125
1/2
✓ Branch 40 → 41 taken 17 times.
✗ Branch 40 → 204 not taken.
 17 truePtr = resolveAddress(trueNode);
126
2/2
✓ Branch 42 → 43 taken 2 times.
✓ Branch 42 → 58 taken 353 times.
 355 } else if (node->trueSideCallsCopyCtor) { // only true side needs copy ctor call
127
1/2
✓ Branch 43 → 44 taken 2 times.
✗ Branch 43 → 204 not taken.
 2 llvm::Value *originalPtr = resolveAddress(trueNode);
128
3/6
✓ Branch 46 → 47 taken 2 times.
✗ Branch 46 → 159 not taken.
✓ Branch 47 → 48 taken 2 times.
✗ Branch 47 → 157 not taken.
✓ Branch 48 → 49 taken 2 times.
✗ Branch 48 → 157 not taken.
 2 truePtr = insertAlloca(trueNode->getEvaluatedSymbolType(manIdx));
129
2/4
✓ Branch 53 → 54 taken 2 times.
✗ Branch 53 → 165 not taken.
✓ Branch 54 → 55 taken 2 times.
✗ Branch 54 → 163 not taken.
 6 generateCtorOrDtorCall(truePtr, node->calledCopyCtor, {originalPtr});
130 } else { // neither true nor false side need copy ctor call
131
1/2
✓ Branch 58 → 59 taken 353 times.
✗ Branch 58 → 204 not taken.
 353 trueValue = resolveValue(trueNode);
132 }
133 // Set the true block to the current insert point, since it could have changed in the meantime
134 372 condTrue = builder.GetInsertBlock();
135
1/2
✓ Branch 61 → 62 taken 372 times.
✗ Branch 61 → 204 not taken.
 372 insertJump(condExit);
136
137 // Fill false block
138
1/2
✓ Branch 62 → 63 taken 372 times.
✗ Branch 62 → 204 not taken.
 372 switchToBlock(condFalse);
139 372 llvm::Value *falseValue = nullptr;
140 372 llvm::Value *falsePtr = nullptr;
141
7/8
✓ Branch 63 → 64 taken 364 times.
✓ Branch 63 → 66 taken 8 times.
✓ Branch 64 → 65 taken 364 times.
✗ Branch 64 → 204 not taken.
✓ Branch 65 → 66 taken 9 times.
✓ Branch 65 → 67 taken 355 times.
✓ Branch 68 → 69 taken 17 times.
✓ Branch 68 → 71 taken 355 times.
 372 if (node->trueSideCallsCopyCtor || resultType.isRef()) { // both sides or only the true side needs copy ctor call
142
1/2
✓ Branch 69 → 70 taken 17 times.
✗ Branch 69 → 204 not taken.
 17 falsePtr = resolveAddress(falseNode);
143
2/2
✓ Branch 71 → 72 taken 2 times.
✓ Branch 71 → 87 taken 353 times.
 355 } else if (node->falseSideCallsCopyCtor) { // only false side needs copy ctor call
144
1/2
✓ Branch 72 → 73 taken 2 times.
✗ Branch 72 → 204 not taken.
 2 llvm::Value *originalPtr = resolveAddress(falseNode);
145
3/6
✓ Branch 75 → 76 taken 2 times.
✗ Branch 75 → 172 not taken.
✓ Branch 76 → 77 taken 2 times.
✗ Branch 76 → 170 not taken.
✓ Branch 77 → 78 taken 2 times.
✗ Branch 77 → 170 not taken.
 2 falsePtr = insertAlloca(falseNode->getEvaluatedSymbolType(manIdx));
146
2/4
✓ Branch 82 → 83 taken 2 times.
✗ Branch 82 → 178 not taken.
✓ Branch 83 → 84 taken 2 times.
✗ Branch 83 → 176 not taken.
 6 generateCtorOrDtorCall(falsePtr, node->calledCopyCtor, {originalPtr});
147 } else { // neither true nor false side need copy ctor call
148
1/2
✓ Branch 87 → 88 taken 353 times.
✗ Branch 87 → 204 not taken.
 353 falseValue = resolveValue(falseNode);
149 }
150 // Set the true block to the current insert point, since it could have changed in the meantime
151 372 condFalse = builder.GetInsertBlock();
152
1/2
✓ Branch 90 → 91 taken 372 times.
✗ Branch 90 → 204 not taken.
 372 insertJump(condExit);
153
154 // Fill the exit block
155
1/2
✓ Branch 91 → 92 taken 372 times.
✗ Branch 91 → 204 not taken.
 372 switchToBlock(condExit);
156
9/10
✓ Branch 92 → 93 taken 364 times.
✓ Branch 92 → 96 taken 8 times.
✓ Branch 93 → 94 taken 362 times.
✓ Branch 93 → 96 taken 2 times.
✓ Branch 94 → 95 taken 362 times.
✗ Branch 94 → 204 not taken.
✓ Branch 95 → 96 taken 9 times.
✓ Branch 95 → 97 taken 353 times.
✓ Branch 98 → 99 taken 19 times.
✓ Branch 98 → 121 taken 353 times.
 372 if (node->trueSideCallsCopyCtor || node->falseSideCallsCopyCtor || resultType.isRef()) { // one side calls copy ctor
157
3/6
✓ Branch 99 → 100 taken 19 times.
✗ Branch 99 → 183 not taken.
✓ Branch 100 → 101 taken 19 times.
✗ Branch 100 → 183 not taken.
✓ Branch 101 → 102 taken 19 times.
✗ Branch 101 → 183 not taken.
 19 llvm::PHINode *phiInst = builder.CreatePHI(builder.getPtrTy(), 2, "cond.result");
158
1/2
✓ Branch 102 → 103 taken 19 times.
✗ Branch 102 → 204 not taken.
 19 phiInst->addIncoming(truePtr, condTrue);
159
1/2
✓ Branch 103 → 104 taken 19 times.
✗ Branch 103 → 204 not taken.
 19 phiInst->addIncoming(falsePtr, condFalse);
160
4/4
✓ Branch 104 → 105 taken 8 times.
✓ Branch 104 → 119 taken 11 times.
✓ Branch 105 → 106 taken 6 times.
✓ Branch 105 → 119 taken 2 times.
 19 if (node->trueSideCallsCopyCtor && node->falseSideCallsCopyCtor) { // both sides need copy ctor call
161
2/4
✓ Branch 108 → 109 taken 6 times.
✗ Branch 108 → 186 not taken.
✓ Branch 109 → 110 taken 6 times.
✗ Branch 109 → 184 not taken.
 6 resultPtr = insertAlloca(resultType);
162
2/4
✓ Branch 114 → 115 taken 6 times.
✗ Branch 114 → 192 not taken.
✓ Branch 115 → 116 taken 6 times.
✗ Branch 115 → 190 not taken.
 18 generateCtorOrDtorCall(resultPtr, node->calledCopyCtor, {phiInst});
163 } else {
164 13 resultPtr = phiInst;
165 }
166 } else { // neither true nor false side calls copy ctor
167
1/2
✗ Branch 121 → 122 not taken.
✓ Branch 121 → 123 taken 353 times.
 353 assert(trueValue != nullptr);
168
3/6
✓ Branch 123 → 124 taken 353 times.
✗ Branch 123 → 197 not taken.
✓ Branch 124 → 125 taken 353 times.
✗ Branch 124 → 197 not taken.
✓ Branch 125 → 126 taken 353 times.
✗ Branch 125 → 197 not taken.
 353 llvm::PHINode *phiInst = builder.CreatePHI(resultType.toLLVMType(sourceFile), 2, "cond.result");
169
1/2
✓ Branch 126 → 127 taken 353 times.
✗ Branch 126 → 204 not taken.
 353 phiInst->addIncoming(trueValue, condTrue);
170
1/2
✓ Branch 127 → 128 taken 353 times.
✗ Branch 127 → 204 not taken.
 353 phiInst->addIncoming(falseValue, condFalse);
171 353 resultValue = phiInst;
172 }
173
174 // If we have an anonymous symbol for this ternary expr, make sure that it has an address to reference.
175
1/2
✓ Branch 129 → 130 taken 372 times.
✗ Branch 129 → 204 not taken.
 372 anonymousSymbol = currentScope->symbolTable.lookupAnonymous(node);
176
2/2
✓ Branch 130 → 131 taken 6 times.
✓ Branch 130 → 141 taken 366 times.
 372 if (anonymousSymbol != nullptr) {
177
1/2
✗ Branch 131 → 132 not taken.
✓ Branch 131 → 140 taken 6 times.
 6 if (!resultPtr) {
178 ✗ resultPtr = insertAlloca(anonymousSymbol->getQualType());
179 ✗ insertStore(resultValue, resultPtr);
180 }
181
1/2
✓ Branch 140 → 141 taken 6 times.
✗ Branch 140 → 204 not taken.
 6 anonymousSymbol->updateAddress(resultPtr);
182 }
183 372 }
184
185
1/2
✓ Branch 143 → 144 taken 498 times.
✗ Branch 143 → 207 not taken.
 996 return LLVMExprResult{.value = resultValue, .ptr = resultPtr, .entry = anonymousSymbol};
186 }
187
188 73992 std::any IRGenerator::visitLogicalOrExpr(const LogicalOrExprNode *node) {
189
1/2
✓ Branch 2 → 3 taken 73992 times.
✗ Branch 2 → 96 not taken.
 73992 diGenerator.setSourceLocation(node);
190
191 // Check if only one operand is present -> loop through
192
2/2
✓ Branch 4 → 5 taken 73024 times.
✓ Branch 4 → 8 taken 968 times.
 73992 if (node->operands.size() == 1)
193
1/2
✓ Branch 6 → 7 taken 73024 times.
✗ Branch 6 → 96 not taken.
 73024 return visit(node->operands.front());
194
195 // It is a logical or expression
196 // Create exit block for short-circuiting
197
1/2
✓ Branch 8 → 9 taken 968 times.
✗ Branch 8 → 96 not taken.
 968 const std::string codeLoc = node->codeLoc.toPrettyLineAndColumn();
198
2/4
✓ Branch 9 → 10 taken 968 times.
✗ Branch 9 → 73 not taken.
✓ Branch 10 → 11 taken 968 times.
✗ Branch 10 → 71 not taken.
 968 llvm::BasicBlock *bExit = createBlock("lor.exit." + codeLoc);
199
200 // Visit the first operand
201
1/2
✓ Branch 13 → 14 taken 968 times.
✗ Branch 13 → 94 not taken.
 968 llvm::Value *firstOperandValue = resolveValue(node->operands.front());
202
203 // Prepare an array for value-to-block-mapping
204 968 std::vector<std::pair<llvm::BasicBlock *, llvm::Value *>> shortCircuitBlocks;
205
1/2
✓ Branch 15 → 16 taken 968 times.
✗ Branch 15 → 92 not taken.
 968 shortCircuitBlocks.reserve(node->operands.size());
206 // The first element is the first operand value with the original block
207
1/2
✓ Branch 17 → 18 taken 968 times.
✗ Branch 17 → 74 not taken.
 968 shortCircuitBlocks.emplace_back(builder.GetInsertBlock(), firstOperandValue);
208 // Create a block for each additional operand and save it to the mapping
209
2/2
✓ Branch 31 → 19 taken 1244 times.
✓ Branch 31 → 32 taken 968 times.
 2212 for (size_t i = 1; i < node->operands.size(); i++)
210
6/12
✓ Branch 19 → 20 taken 1244 times.
✗ Branch 19 → 83 not taken.
✓ Branch 20 → 21 taken 1244 times.
✗ Branch 20 → 81 not taken.
✓ Branch 21 → 22 taken 1244 times.
✗ Branch 21 → 79 not taken.
✓ Branch 22 → 23 taken 1244 times.
✗ Branch 22 → 77 not taken.
✓ Branch 23 → 24 taken 1244 times.
✗ Branch 23 → 75 not taken.
✓ Branch 24 → 25 taken 1244 times.
✗ Branch 24 → 75 not taken.
 1244 shortCircuitBlocks.emplace_back(createBlock("lor." + std::to_string(i) + "." + codeLoc), nullptr);
211 // Create conditional jump to the exit block if the first operand was true, otherwise to the next block
212
2/4
✓ Branch 32 → 33 taken 968 times.
✗ Branch 32 → 92 not taken.
✓ Branch 33 → 34 taken 968 times.
✗ Branch 33 → 92 not taken.
 968 insertCondJump(firstOperandValue, bExit, shortCircuitBlocks.at(1).first);
213
214 // Create block for each operand
215
2/2
✓ Branch 50 → 35 taken 1244 times.
✓ Branch 50 → 51 taken 968 times.
 2212 for (size_t i = 1; i < node->operands.size(); i++) {
216 // Switch to the next block
217
2/4
✓ Branch 35 → 36 taken 1244 times.
✗ Branch 35 → 92 not taken.
✓ Branch 36 → 37 taken 1244 times.
✗ Branch 36 → 92 not taken.
 1244 switchToBlock(shortCircuitBlocks.at(i).first);
218 // Evaluate operand and save the result in the mapping
219
2/4
✓ Branch 38 → 39 taken 1244 times.
✗ Branch 38 → 92 not taken.
✓ Branch 39 → 40 taken 1244 times.
✗ Branch 39 → 92 not taken.
 1244 shortCircuitBlocks.at(i).second = resolveValue(node->operands[i]);
220 // Replace the array entry with the current insert block, since the insert block could have changed in the meantime
221
1/2
✓ Branch 41 → 42 taken 1244 times.
✗ Branch 41 → 92 not taken.
 1244 shortCircuitBlocks.at(i).first = builder.GetInsertBlock();
222 // Check if there are more blocks to process
223
2/2
✓ Branch 43 → 44 taken 968 times.
✓ Branch 43 → 45 taken 276 times.
 1244 if (i == node->operands.size() - 1) {
224 // Insert a simple jump to the exit block for the last block
225
1/2
✓ Branch 44 → 48 taken 968 times.
✗ Branch 44 → 92 not taken.
 968 insertJump(bExit);
226 } else {
227 // Create conditional jump to the exit block if the first operand was true, otherwise to the next block
228
3/6
✓ Branch 45 → 46 taken 276 times.
✗ Branch 45 → 92 not taken.
✓ Branch 46 → 47 taken 276 times.
✗ Branch 46 → 92 not taken.
✓ Branch 47 → 48 taken 276 times.
✗ Branch 47 → 92 not taken.
 276 insertCondJump(shortCircuitBlocks.at(i).second, bExit, shortCircuitBlocks.at(i + 1).first);
229 }
230 }
231
232 // Get the result with the phi node
233
1/2
✓ Branch 51 → 52 taken 968 times.
✗ Branch 51 → 92 not taken.
 968 switchToBlock(bExit);
234
2/4
✓ Branch 52 → 53 taken 968 times.
✗ Branch 52 → 89 not taken.
✓ Branch 55 → 56 taken 968 times.
✗ Branch 55 → 89 not taken.
 968 llvm::PHINode *result = builder.CreatePHI(firstOperandValue->getType(), node->operands.size(), "lor_phi");
235
2/2
✓ Branch 64 → 58 taken 2212 times.
✓ Branch 64 → 65 taken 968 times.
 3180 for (const auto &[incomingBlock, value] : shortCircuitBlocks)
236
1/2
✓ Branch 61 → 62 taken 2212 times.
✗ Branch 61 → 90 not taken.
 2212 result->addIncoming(value, incomingBlock);
237
238 // Return the result
239
1/2
✓ Branch 65 → 66 taken 968 times.
✗ Branch 65 → 91 not taken.
 968 return LLVMExprResult{.value = result};
240 968 }
241
242 75236 std::any IRGenerator::visitLogicalAndExpr(const LogicalAndExprNode *node) {
243
1/2
✓ Branch 2 → 3 taken 75236 times.
✗ Branch 2 → 96 not taken.
 75236 diGenerator.setSourceLocation(node);
244
245 // Check if only one operand is present -> loop through
246
2/2
✓ Branch 4 → 5 taken 75050 times.
✓ Branch 4 → 8 taken 186 times.
 75236 if (node->operands.size() == 1)
247
1/2
✓ Branch 6 → 7 taken 75050 times.
✗ Branch 6 → 96 not taken.
 75050 return visit(node->operands.front());
248
249 // It is a logical and expression
250 // Create exit block for short-circuiting
251
1/2
✓ Branch 8 → 9 taken 186 times.
✗ Branch 8 → 96 not taken.
 186 const std::string codeLoc = node->codeLoc.toPrettyLineAndColumn();
252
2/4
✓ Branch 9 → 10 taken 186 times.
✗ Branch 9 → 73 not taken.
✓ Branch 10 → 11 taken 186 times.
✗ Branch 10 → 71 not taken.
 186 llvm::BasicBlock *bExit = createBlock("land.exit." + codeLoc);
253
254 // Visit the first operand
255
1/2
✓ Branch 13 → 14 taken 186 times.
✗ Branch 13 → 94 not taken.
 186 llvm::Value *firstOperandValue = resolveValue(node->operands.front());
256
257 // Prepare an array for value-to-block-mapping
258 186 std::vector<std::pair<llvm::BasicBlock *, llvm::Value *>> shortCircuitBlocks;
259
1/2
✓ Branch 15 → 16 taken 186 times.
✗ Branch 15 → 92 not taken.
 186 shortCircuitBlocks.reserve(node->operands.size());
260 // The first element is the first operand value with the original block
261
1/2
✓ Branch 17 → 18 taken 186 times.
✗ Branch 17 → 74 not taken.
 186 shortCircuitBlocks.emplace_back(builder.GetInsertBlock(), firstOperandValue);
262 // Create a block for each additional operand and save it to the mapping
263
2/2
✓ Branch 31 → 19 taken 219 times.
✓ Branch 31 → 32 taken 186 times.
 405 for (size_t i = 1; i < node->operands.size(); i++)
264
6/12
✓ Branch 19 → 20 taken 219 times.
✗ Branch 19 → 83 not taken.
✓ Branch 20 → 21 taken 219 times.
✗ Branch 20 → 81 not taken.
✓ Branch 21 → 22 taken 219 times.
✗ Branch 21 → 79 not taken.
✓ Branch 22 → 23 taken 219 times.
✗ Branch 22 → 77 not taken.
✓ Branch 23 → 24 taken 219 times.
✗ Branch 23 → 75 not taken.
✓ Branch 24 → 25 taken 219 times.
✗ Branch 24 → 75 not taken.
 219 shortCircuitBlocks.emplace_back(createBlock("land." + std::to_string(i) + "." + codeLoc), nullptr);
265 // Create conditional jump to the exit block if the first operand was true, otherwise to the next block
266
2/4
✓ Branch 32 → 33 taken 186 times.
✗ Branch 32 → 92 not taken.
✓ Branch 33 → 34 taken 186 times.
✗ Branch 33 → 92 not taken.
 186 insertCondJump(firstOperandValue, shortCircuitBlocks.at(1).first, bExit);
267
268 // Create block for each operand
269
2/2
✓ Branch 50 → 35 taken 219 times.
✓ Branch 50 → 51 taken 186 times.
 405 for (size_t i = 1; i < node->operands.size(); i++) {
270 // Switch to the next block
271
2/4
✓ Branch 35 → 36 taken 219 times.
✗ Branch 35 → 92 not taken.
✓ Branch 36 → 37 taken 219 times.
✗ Branch 36 → 92 not taken.
 219 switchToBlock(shortCircuitBlocks.at(i).first);
272 // Evaluate operand and save the result in the mapping
273
2/4
✓ Branch 38 → 39 taken 219 times.
✗ Branch 38 → 92 not taken.
✓ Branch 39 → 40 taken 219 times.
✗ Branch 39 → 92 not taken.
 219 shortCircuitBlocks.at(i).second = resolveValue(node->operands[i]);
274 // Replace the array entry with the current insert block, since the insert block could have changed in the meantime
275
1/2
✓ Branch 41 → 42 taken 219 times.
✗ Branch 41 → 92 not taken.
 219 shortCircuitBlocks.at(i).first = builder.GetInsertBlock();
276 // Check if there are more blocks to process
277
2/2
✓ Branch 43 → 44 taken 186 times.
✓ Branch 43 → 45 taken 33 times.
 219 if (i == node->operands.size() - 1) {
278 // Insert a simple jump to the exit block for the last block
279
1/2
✓ Branch 44 → 48 taken 186 times.
✗ Branch 44 → 92 not taken.
 186 insertJump(bExit);
280 } else {
281 // Create conditional jump to the exit block if the operand was true, otherwise to the next block
282
3/6
✓ Branch 45 → 46 taken 33 times.
✗ Branch 45 → 92 not taken.
✓ Branch 46 → 47 taken 33 times.
✗ Branch 46 → 92 not taken.
✓ Branch 47 → 48 taken 33 times.
✗ Branch 47 → 92 not taken.
 33 insertCondJump(shortCircuitBlocks.at(i).second, shortCircuitBlocks.at(i + 1).first, bExit);
283 }
284 }
285
286 // Get the result with the phi node
287
1/2
✓ Branch 51 → 52 taken 186 times.
✗ Branch 51 → 92 not taken.
 186 switchToBlock(bExit);
288
2/4
✓ Branch 52 → 53 taken 186 times.
✗ Branch 52 → 89 not taken.
✓ Branch 55 → 56 taken 186 times.
✗ Branch 55 → 89 not taken.
 186 llvm::PHINode *result = builder.CreatePHI(firstOperandValue->getType(), node->operands.size(), "land_phi");
289
2/2
✓ Branch 64 → 58 taken 405 times.
✓ Branch 64 → 65 taken 186 times.
 591 for (const auto &[incomingBlock, value] : shortCircuitBlocks)
290
1/2
✓ Branch 61 → 62 taken 405 times.
✗ Branch 61 → 90 not taken.
 405 result->addIncoming(value, incomingBlock);
291
292 // Return the result
293
1/2
✓ Branch 65 → 66 taken 186 times.
✗ Branch 65 → 91 not taken.
 186 return LLVMExprResult{.value = result};
294 186 }
295
296 75455 std::any IRGenerator::visitBitwiseOrExpr(const BitwiseOrExprNode *node) {
297
1/2
✓ Branch 2 → 3 taken 75455 times.
✗ Branch 2 → 34 not taken.
 75455 diGenerator.setSourceLocation(node);
298
299 // Check if only one operand is present -> loop through
300
2/2
✓ Branch 4 → 5 taken 75364 times.
✓ Branch 4 → 8 taken 91 times.
 75455 if (node->operands.size() == 1)
301
1/2
✓ Branch 6 → 7 taken 75364 times.
✗ Branch 6 → 34 not taken.
 75364 return visit(node->operands.front());
302
303 // It is a bitwise or expression
304 // Evaluate first operand
305 91 const BitwiseXorExprNode *lhsNode = node->operands.front();
306
1/2
✓ Branch 9 → 10 taken 91 times.
✗ Branch 9 → 34 not taken.
 91 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
307
2/4
✓ Branch 10 → 11 taken 91 times.
✗ Branch 10 → 29 not taken.
✓ Branch 11 → 12 taken 91 times.
✗ Branch 11 → 27 not taken.
 91 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
308
309 // Evaluate all additional operands
310
2/2
✓ Branch 22 → 14 taken 92 times.
✓ Branch 22 → 23 taken 91 times.
 183 for (size_t i = 1; i < node->operands.size(); i++) {
311 // Evaluate the operand
312 92 const BitwiseXorExprNode *rhsNode = node->operands[i];
313
1/2
✓ Branch 15 → 16 taken 92 times.
✗ Branch 15 → 33 not taken.
 92 const QualType rhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
314
2/4
✓ Branch 16 → 17 taken 92 times.
✗ Branch 16 → 32 not taken.
✓ Branch 17 → 18 taken 92 times.
✗ Branch 17 → 30 not taken.
 92 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
315
1/2
✓ Branch 19 → 20 taken 92 times.
✗ Branch 19 → 33 not taken.
 92 result = conversionManager.getBitwiseOrInst(node, result, lhsSTy, rhs, rhsSTy, i - 1);
316 }
317
318 // Return result
319
1/2
✓ Branch 23 → 24 taken 91 times.
✗ Branch 23 → 34 not taken.
 91 return result;
320 }
321
322 75547 std::any IRGenerator::visitBitwiseXorExpr(const BitwiseXorExprNode *node) {
323
1/2
✓ Branch 2 → 3 taken 75547 times.
✗ Branch 2 → 34 not taken.
 75547 diGenerator.setSourceLocation(node);
324
325 // Check if only one operand is present -> loop through
326
2/2
✓ Branch 4 → 5 taken 75533 times.
✓ Branch 4 → 8 taken 14 times.
 75547 if (node->operands.size() == 1)
327
1/2
✓ Branch 6 → 7 taken 75533 times.
✗ Branch 6 → 34 not taken.
 75533 return visit(node->operands.front());
328
329 // It is a bitwise xor expression
330 // Evaluate first operand
331 14 const BitwiseAndExprNode *lhsNode = node->operands.front();
332
1/2
✓ Branch 9 → 10 taken 14 times.
✗ Branch 9 → 34 not taken.
 14 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
333
2/4
✓ Branch 10 → 11 taken 14 times.
✗ Branch 10 → 29 not taken.
✓ Branch 11 → 12 taken 14 times.
✗ Branch 11 → 27 not taken.
 14 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
334
335 // Evaluate all additional operands
336
2/2
✓ Branch 22 → 14 taken 15 times.
✓ Branch 22 → 23 taken 14 times.
 29 for (size_t i = 1; i < node->operands.size(); i++) {
337 // Evaluate the operand
338 15 const BitwiseAndExprNode *rhsNode = node->operands[i];
339
1/2
✓ Branch 15 → 16 taken 15 times.
✗ Branch 15 → 33 not taken.
 15 const QualType rhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
340
2/4
✓ Branch 16 → 17 taken 15 times.
✗ Branch 16 → 32 not taken.
✓ Branch 17 → 18 taken 15 times.
✗ Branch 17 → 30 not taken.
 15 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
341
1/2
✓ Branch 19 → 20 taken 15 times.
✗ Branch 19 → 33 not taken.
 15 result = conversionManager.getBitwiseXorInst(node, result, lhsSTy, rhs, rhsSTy);
342 }
343
344 // Return result
345
1/2
✓ Branch 23 → 24 taken 14 times.
✗ Branch 23 → 34 not taken.
 14 return result;
346 }
347
348 75562 std::any IRGenerator::visitBitwiseAndExpr(const BitwiseAndExprNode *node) {
349
1/2
✓ Branch 2 → 3 taken 75562 times.
✗ Branch 2 → 34 not taken.
 75562 diGenerator.setSourceLocation(node);
350
351 // Check if only one operand is present -> loop through
352
2/2
✓ Branch 4 → 5 taken 75516 times.
✓ Branch 4 → 8 taken 46 times.
 75562 if (node->operands.size() == 1)
353
1/2
✓ Branch 6 → 7 taken 75516 times.
✗ Branch 6 → 34 not taken.
 75516 return visit(node->operands.front());
354
355 // It is a bitwise and expression
356 // Evaluate first operand
357 46 const EqualityExprNode *lhsNode = node->operands.front();
358
1/2
✓ Branch 9 → 10 taken 46 times.
✗ Branch 9 → 34 not taken.
 46 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
359
2/4
✓ Branch 10 → 11 taken 46 times.
✗ Branch 10 → 29 not taken.
✓ Branch 11 → 12 taken 46 times.
✗ Branch 11 → 27 not taken.
 46 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
360
361 // Evaluate all additional operands
362
2/2
✓ Branch 22 → 14 taken 47 times.
✓ Branch 22 → 23 taken 46 times.
 93 for (size_t i = 1; i < node->operands.size(); i++) {
363 // Evaluate the operand
364 47 const EqualityExprNode *rhsNode = node->operands[i];
365
1/2
✓ Branch 15 → 16 taken 47 times.
✗ Branch 15 → 33 not taken.
 47 const QualType rhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
366
2/4
✓ Branch 16 → 17 taken 47 times.
✗ Branch 16 → 32 not taken.
✓ Branch 17 → 18 taken 47 times.
✗ Branch 17 → 30 not taken.
 47 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
367
1/2
✓ Branch 19 → 20 taken 47 times.
✗ Branch 19 → 33 not taken.
 47 result = conversionManager.getBitwiseAndInst(rhsNode, result, lhsSTy, rhs, rhsSTy, i - 1);
368 }
369
370 // Return result
371
1/2
✓ Branch 23 → 24 taken 46 times.
✗ Branch 23 → 34 not taken.
 46 return result;
372 }
373
374 75609 std::any IRGenerator::visitEqualityExpr(const EqualityExprNode *node) {
375
1/2
✓ Branch 2 → 3 taken 75609 times.
✗ Branch 2 → 50 not taken.
 75609 diGenerator.setSourceLocation(node);
376
377 // Check if only one operand is present -> loop through
378
2/2
✓ Branch 4 → 5 taken 69807 times.
✓ Branch 4 → 8 taken 5802 times.
 75609 if (node->operands.size() == 1)
379
1/2
✓ Branch 6 → 7 taken 69807 times.
✗ Branch 6 → 50 not taken.
 69807 return visit(node->operands.front());
380
381 // It is an equality expression
382 // Evaluate lhs
383 5802 const RelationalExprNode *lhsNode = node->operands[0];
384
1/2
✓ Branch 9 → 10 taken 5802 times.
✗ Branch 9 → 50 not taken.
 5802 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
385
2/4
✓ Branch 10 → 11 taken 5802 times.
✗ Branch 10 → 37 not taken.
✓ Branch 11 → 12 taken 5802 times.
✗ Branch 11 → 35 not taken.
 5802 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
386
387 // Evaluate rhs
388 5802 const RelationalExprNode *rhsNode = node->operands[1];
389
1/2
✓ Branch 14 → 15 taken 5802 times.
✗ Branch 14 → 50 not taken.
 5802 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
390
2/4
✓ Branch 15 → 16 taken 5802 times.
✗ Branch 15 → 40 not taken.
✓ Branch 16 → 17 taken 5802 times.
✗ Branch 16 → 38 not taken.
 5802 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
391
392 // Retrieve the result value, based on the exact operator
393
2/3
✓ Branch 18 → 19 taken 4255 times.
✓ Branch 18 → 21 taken 1547 times.
✗ Branch 18 → 23 not taken.
 5802 switch (node->op) {
394 4255 case EqualityExprNode::EqualityOp::OP_EQUAL:
395
1/2
✓ Branch 19 → 20 taken 4255 times.
✗ Branch 19 → 50 not taken.
 4255 result = conversionManager.getEqualInst(node, result, lhsSTy, rhs, rhsSTy);
396 4255 break;
397 1547 case EqualityExprNode::EqualityOp::OP_NOT_EQUAL:
398
1/2
✓ Branch 21 → 22 taken 1547 times.
✗ Branch 21 → 50 not taken.
 1547 result = conversionManager.getNotEqualInst(node, result, lhsSTy, rhs, rhsSTy);
399 1547 break;
400 − default: // GCOV_EXCL_LINE
401 − throw CompilerError(UNHANDLED_BRANCH, "EqualityExpr fall-through"); // GCOV_EXCL_LINE
402 }
403
404 // Return the result
405
1/2
✓ Branch 31 → 32 taken 5802 times.
✗ Branch 31 → 50 not taken.
 5802 return result;
406 }
407
408 81411 std::any IRGenerator::visitRelationalExpr(const RelationalExprNode *node) {
409
1/2
✓ Branch 2 → 3 taken 81411 times.
✗ Branch 2 → 54 not taken.
 81411 diGenerator.setSourceLocation(node);
410
411 // Check if only one operand is present -> loop through
412
2/2
✓ Branch 4 → 5 taken 77561 times.
✓ Branch 4 → 8 taken 3850 times.
 81411 if (node->operands.size() == 1)
413
1/2
✓ Branch 6 → 7 taken 77561 times.
✗ Branch 6 → 54 not taken.
 77561 return visit(node->operands.front());
414
415 // It is a relational expression
416 // Evaluate lhs
417 3850 const ShiftExprNode *lhsNode = node->operands[0];
418
1/2
✓ Branch 9 → 10 taken 3850 times.
✗ Branch 9 → 54 not taken.
 3850 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
419
2/4
✓ Branch 10 → 11 taken 3850 times.
✗ Branch 10 → 41 not taken.
✓ Branch 11 → 12 taken 3850 times.
✗ Branch 11 → 39 not taken.
 3850 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
420
421 // Evaluate rhs
422 3850 const ShiftExprNode *rhsNode = node->operands[1];
423
1/2
✓ Branch 14 → 15 taken 3850 times.
✗ Branch 14 → 54 not taken.
 3850 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
424
2/4
✓ Branch 15 → 16 taken 3850 times.
✗ Branch 15 → 44 not taken.
✓ Branch 16 → 17 taken 3850 times.
✗ Branch 16 → 42 not taken.
 3850 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
425
426 // Retrieve the result value, based on the exact operator
427
4/5
✓ Branch 18 → 19 taken 1881 times.
✓ Branch 18 → 21 taken 548 times.
✓ Branch 18 → 23 taken 405 times.
✓ Branch 18 → 25 taken 1016 times.
✗ Branch 18 → 27 not taken.
 3850 switch (node->op) {
428 1881 case RelationalExprNode::RelationalOp::OP_LESS:
429
1/2
✓ Branch 19 → 20 taken 1881 times.
✗ Branch 19 → 54 not taken.
 1881 result = conversionManager.getLessInst(node, result, lhsSTy, rhs, rhsSTy);
430 1881 break;
431 548 case RelationalExprNode::RelationalOp::OP_GREATER:
432
1/2
✓ Branch 21 → 22 taken 548 times.
✗ Branch 21 → 54 not taken.
 548 result = conversionManager.getGreaterInst(node, result, lhsSTy, rhs, rhsSTy);
433 548 break;
434 405 case RelationalExprNode::RelationalOp::OP_LESS_EQUAL:
435
1/2
✓ Branch 23 → 24 taken 405 times.
✗ Branch 23 → 54 not taken.
 405 result = conversionManager.getLessEqualInst(node, result, lhsSTy, rhs, rhsSTy);
436 405 break;
437 1016 case RelationalExprNode::RelationalOp::OP_GREATER_EQUAL:
438
1/2
✓ Branch 25 → 26 taken 1016 times.
✗ Branch 25 → 54 not taken.
 1016 result = conversionManager.getGreaterEqualInst(node, result, lhsSTy, rhs, rhsSTy);
439 1016 break;
440 − default: // GCOV_EXCL_LINE
441 − throw CompilerError(UNHANDLED_BRANCH, "EqualityExpr fall-through"); // GCOV_EXCL_LINE
442 }
443
444 // Return the result
445
1/2
✓ Branch 35 → 36 taken 3850 times.
✗ Branch 35 → 54 not taken.
 3850 return result;
446 }
447
448 85261 std::any IRGenerator::visitShiftExpr(const ShiftExprNode *node) {
449
1/2
✓ Branch 2 → 3 taken 85261 times.
✗ Branch 2 → 64 not taken.
 85261 diGenerator.setSourceLocation(node);
450
451 // Check if only one operand is present -> loop through
452
2/2
✓ Branch 4 → 5 taken 85124 times.
✓ Branch 4 → 8 taken 137 times.
 85261 if (node->operands.size() == 1)
453
1/2
✓ Branch 6 → 7 taken 85124 times.
✗ Branch 6 → 64 not taken.
 85124 return visit(node->operands.front());
454
455 // It is a shift expression
456 // Evaluate first operand
457 137 const AdditiveExprNode *lhsNode = node->operands.front();
458
1/2
✓ Branch 9 → 10 taken 137 times.
✗ Branch 9 → 64 not taken.
 137 QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
459
2/4
✓ Branch 10 → 11 taken 137 times.
✗ Branch 10 → 48 not taken.
✓ Branch 11 → 12 taken 137 times.
✗ Branch 11 → 46 not taken.
 137 auto lhs = std::any_cast<LLVMExprResult>(visit(lhsNode));
460
461
1/2
✓ Branch 13 → 14 taken 137 times.
✗ Branch 13 → 64 not taken.
 137 auto opQueue = node->opQueue;
462 137 size_t operandIndex = 1;
463
2/2
✓ Branch 40 → 15 taken 177 times.
✓ Branch 40 → 41 taken 137 times.
 314 while (!opQueue.empty()) {
464 177 const size_t operatorIndex = operandIndex - 1;
465 // Evaluate next operand
466 177 const AdditiveExprNode *rhsNode = node->operands[operandIndex++];
467
1/2
✗ Branch 16 → 17 not taken.
✓ Branch 16 → 18 taken 177 times.
 177 assert(rhsNode != nullptr);
468
1/2
✓ Branch 18 → 19 taken 177 times.
✗ Branch 18 → 61 not taken.
 177 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
469
2/4
✓ Branch 19 → 20 taken 177 times.
✗ Branch 19 → 51 not taken.
✓ Branch 20 → 21 taken 177 times.
✗ Branch 20 → 49 not taken.
 177 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
470
471 // Retrieve the result, based on the exact operator
472
2/3
✓ Branch 23 → 24 taken 110 times.
✓ Branch 23 → 26 taken 67 times.
✗ Branch 23 → 28 not taken.
 177 switch (opQueue.front().first) {
473 110 case ShiftExprNode::ShiftOp::OP_SHIFT_LEFT:
474
1/2
✓ Branch 24 → 25 taken 110 times.
✗ Branch 24 → 61 not taken.
 110 lhs = conversionManager.getShiftLeftInst(node, lhs, lhsSTy, rhs, rhsSTy, operatorIndex);
475 110 break;
476 67 case ShiftExprNode::ShiftOp::OP_SHIFT_RIGHT:
477
1/2
✓ Branch 26 → 27 taken 67 times.
✗ Branch 26 → 61 not taken.
 67 lhs = conversionManager.getShiftRightInst(node, lhs, lhsSTy, rhs, rhsSTy, operatorIndex);
478 67 break;
479 − default: // GCOV_EXCL_LINE
480 − throw CompilerError(UNHANDLED_BRANCH, "AdditiveExpr fall-through"); // GCOV_EXCL_LINE
481 }
482
483 // Retrieve the new lhs symbol type
484 177 lhsSTy = opQueue.front().second;
485
486 177 opQueue.pop();
487 }
488
489 // Return the result
490
1/2
✓ Branch 41 → 42 taken 137 times.
✗ Branch 41 → 62 not taken.
 137 return lhs;
491 137 }
492
493 85438 std::any IRGenerator::visitAdditiveExpr(const AdditiveExprNode *node) {
494
1/2
✓ Branch 2 → 3 taken 85438 times.
✗ Branch 2 → 64 not taken.
 85438 diGenerator.setSourceLocation(node);
495
496 // Check if only one operand is present -> loop through
497
2/2
✓ Branch 4 → 5 taken 81197 times.
✓ Branch 4 → 8 taken 4241 times.
 85438 if (node->operands.size() == 1)
498
1/2
✓ Branch 6 → 7 taken 81197 times.
✗ Branch 6 → 64 not taken.
 81197 return visit(node->operands.front());
499
500 // It is an additive expression
501 // Evaluate first operand
502 4241 const MultiplicativeExprNode *lhsNode = node->operands[0];
503
1/2
✓ Branch 9 → 10 taken 4241 times.
✗ Branch 9 → 64 not taken.
 4241 QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
504
2/4
✓ Branch 10 → 11 taken 4241 times.
✗ Branch 10 → 48 not taken.
✓ Branch 11 → 12 taken 4241 times.
✗ Branch 11 → 46 not taken.
 4241 auto lhs = std::any_cast<LLVMExprResult>(visit(lhsNode));
505
506
1/2
✓ Branch 13 → 14 taken 4241 times.
✗ Branch 13 → 64 not taken.
 4241 auto opQueue = node->opQueue;
507 4241 size_t operandIndex = 1;
508
2/2
✓ Branch 40 → 15 taken 4828 times.
✓ Branch 40 → 41 taken 4241 times.
 9069 while (!opQueue.empty()) {
509 4828 const size_t operatorIndex = operandIndex - 1;
510 // Evaluate next operand
511 4828 const MultiplicativeExprNode *rhsNode = node->operands[operandIndex++];
512
1/2
✗ Branch 16 → 17 not taken.
✓ Branch 16 → 18 taken 4828 times.
 4828 assert(rhsNode != nullptr);
513
1/2
✓ Branch 18 → 19 taken 4828 times.
✗ Branch 18 → 61 not taken.
 4828 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
514
2/4
✓ Branch 19 → 20 taken 4828 times.
✗ Branch 19 → 51 not taken.
✓ Branch 20 → 21 taken 4828 times.
✗ Branch 20 → 49 not taken.
 4828 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
515
516 // Retrieve the result, based on the exact operator
517
2/3
✓ Branch 23 → 24 taken 2944 times.
✓ Branch 23 → 26 taken 1884 times.
✗ Branch 23 → 28 not taken.
 4828 switch (opQueue.front().first) {
518 2944 case AdditiveExprNode::AdditiveOp::OP_PLUS:
519
1/2
✓ Branch 24 → 25 taken 2944 times.
✗ Branch 24 → 61 not taken.
 2944 lhs = conversionManager.getPlusInst(node, lhs, lhsSTy, rhs, rhsSTy, operatorIndex);
520 2944 break;
521 1884 case AdditiveExprNode::AdditiveOp::OP_MINUS:
522
1/2
✓ Branch 26 → 27 taken 1884 times.
✗ Branch 26 → 61 not taken.
 1884 lhs = conversionManager.getMinusInst(node, lhs, lhsSTy, rhs, rhsSTy, operatorIndex);
523 1884 break;
524 − default: // GCOV_EXCL_LINE
525 − throw CompilerError(UNHANDLED_BRANCH, "AdditiveExpr fall-through"); // GCOV_EXCL_LINE
526 }
527
528 // Retrieve the new lhs symbol type
529 4828 lhsSTy = opQueue.front().second;
530
531 4828 opQueue.pop();
532 }
533
534 // Return the result
535
1/2
✓ Branch 41 → 42 taken 4241 times.
✗ Branch 41 → 62 not taken.
 4241 return lhs;
536 4241 }
537
538 90266 std::any IRGenerator::visitMultiplicativeExpr(const MultiplicativeExprNode *node) {
539
1/2
✓ Branch 2 → 3 taken 90266 times.
✗ Branch 2 → 66 not taken.
 90266 diGenerator.setSourceLocation(node);
540
541 // Check if only one operand is present -> loop through
542
2/2
✓ Branch 4 → 5 taken 89331 times.
✓ Branch 4 → 8 taken 935 times.
 90266 if (node->operands.size() == 1)
543
1/2
✓ Branch 6 → 7 taken 89331 times.
✗ Branch 6 → 66 not taken.
 89331 return visit(node->operands.front());
544
545 // It is an additive expression
546 // Evaluate first operand
547 935 const CastExprNode *lhsNode = node->operands[0];
548
1/2
✓ Branch 9 → 10 taken 935 times.
✗ Branch 9 → 66 not taken.
 935 QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
549
2/4
✓ Branch 10 → 11 taken 935 times.
✗ Branch 10 → 50 not taken.
✓ Branch 11 → 12 taken 935 times.
✗ Branch 11 → 48 not taken.
 935 auto result = std::any_cast<LLVMExprResult>(visit(lhsNode));
550
551
1/2
✓ Branch 13 → 14 taken 935 times.
✗ Branch 13 → 66 not taken.
 935 auto opQueue = node->opQueue;
552 935 size_t operandIndex = 1;
553
2/2
✓ Branch 42 → 15 taken 955 times.
✓ Branch 42 → 43 taken 935 times.
 1890 while (!opQueue.empty()) {
554 955 const size_t operatorIndex = operandIndex - 1;
555 // Evaluate next operand
556 955 const CastExprNode *rhsNode = node->operands[operandIndex++];
557
1/2
✗ Branch 16 → 17 not taken.
✓ Branch 16 → 18 taken 955 times.
 955 assert(rhsNode != nullptr);
558
1/2
✓ Branch 18 → 19 taken 955 times.
✗ Branch 18 → 63 not taken.
 955 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
559
2/4
✓ Branch 19 → 20 taken 955 times.
✗ Branch 19 → 53 not taken.
✓ Branch 20 → 21 taken 955 times.
✗ Branch 20 → 51 not taken.
 955 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
560
561 // Retrieve the result, based on the exact operator
562
3/4
✓ Branch 23 → 24 taken 777 times.
✓ Branch 23 → 26 taken 153 times.
✓ Branch 23 → 28 taken 25 times.
✗ Branch 23 → 30 not taken.
 955 switch (opQueue.front().first) {
563 777 case MultiplicativeExprNode::MultiplicativeOp::OP_MUL:
564
1/2
✓ Branch 24 → 25 taken 777 times.
✗ Branch 24 → 63 not taken.
 777 result = conversionManager.getMulInst(node, result, lhsSTy, rhs, rhsSTy, operatorIndex);
565 777 break;
566 153 case MultiplicativeExprNode::MultiplicativeOp::OP_DIV:
567
1/2
✓ Branch 26 → 27 taken 153 times.
✗ Branch 26 → 63 not taken.
 153 result = conversionManager.getDivInst(node, result, lhsSTy, rhs, rhsSTy, operatorIndex);
568 153 break;
569 25 case MultiplicativeExprNode::MultiplicativeOp::OP_REM:
570
1/2
✓ Branch 28 → 29 taken 25 times.
✗ Branch 28 → 63 not taken.
 25 result = conversionManager.getRemInst(node, result, lhsSTy, rhs, rhsSTy);
571 25 break;
572 − default: // GCOV_EXCL_LINE
573 − throw CompilerError(UNHANDLED_BRANCH, "MultiplicativeExpr fall-through"); // GCOV_EXCL_LINE
574 }
575
576 // Retrieve the new lhs symbol type
577 955 lhsSTy = opQueue.front().second;
578 955 opQueue.pop();
579 }
580
581 // Return the result
582
1/2
✓ Branch 43 → 44 taken 935 times.
✗ Branch 43 → 64 not taken.
 935 return result;
583 935 }
584
585 91221 std::any IRGenerator::visitCastExpr(const CastExprNode *node) {
586
1/2
✓ Branch 2 → 3 taken 91221 times.
✗ Branch 2 → 19 not taken.
 91221 diGenerator.setSourceLocation(node);
587
588 // Check if only one operand is present -> loop through
589
2/2
✓ Branch 3 → 4 taken 88603 times.
✓ Branch 3 → 6 taken 2618 times.
 91221 if (!node->isCast)
590
1/2
✓ Branch 4 → 5 taken 88603 times.
✗ Branch 4 → 19 not taken.
 88603 return visit(node->prefixUnaryExpr);
591
592 // It is a cast expression
593 // Retrieve target symbol type
594
1/2
✓ Branch 6 → 7 taken 2618 times.
✗ Branch 6 → 19 not taken.
 2618 const QualType targetSTy = node->getEvaluatedSymbolType(manIdx);
595
596 // Evaluate rhs
597 2618 const AssignExprNode *rhsNode = node->assignExpr;
598
1/2
✓ Branch 7 → 8 taken 2618 times.
✗ Branch 7 → 19 not taken.
 2618 const QualType rhsSTy = rhsNode->getEvaluatedSymbolType(manIdx);
599
2/4
✓ Branch 8 → 9 taken 2618 times.
✗ Branch 8 → 18 not taken.
✓ Branch 9 → 10 taken 2618 times.
✗ Branch 9 → 16 not taken.
 2618 auto rhs = std::any_cast<LLVMExprResult>(visit(rhsNode));
600
601 // Retrieve the result value
602
1/2
✓ Branch 11 → 12 taken 2618 times.
✗ Branch 11 → 19 not taken.
 2618 const LLVMExprResult result = conversionManager.getCastInst(node, targetSTy, rhs, rhsSTy);
603
604 // Return the result
605
1/2
✓ Branch 12 → 13 taken 2618 times.
✗ Branch 12 → 19 not taken.
 2618 return result;
606 }
607
608 97267 std::any IRGenerator::visitPrefixUnaryExpr(const PrefixUnaryExprNode *node) {
609
1/2
✓ Branch 2 → 3 taken 97267 times.
✗ Branch 2 → 117 not taken.
 97267 diGenerator.setSourceLocation(node);
610
611 // If no operator is applied, simply visit the atomic expression
612
2/2
✓ Branch 3 → 4 taken 95195 times.
✓ Branch 3 → 6 taken 2072 times.
 97267 if (node->op == PrefixUnaryExprNode::PrefixUnaryOp::OP_NONE)
613
1/2
✓ Branch 4 → 5 taken 95195 times.
✗ Branch 4 → 117 not taken.
 95195 return visit(node->postfixUnaryExpr);
614
615 // Evaluate lhs
616 2072 const PrefixUnaryExprNode *lhsNode = node->prefixUnaryExpr;
617
1/2
✓ Branch 6 → 7 taken 2072 times.
✗ Branch 6 → 117 not taken.
 2072 const QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
618
2/4
✓ Branch 7 → 8 taken 2072 times.
✗ Branch 7 → 87 not taken.
✓ Branch 8 → 9 taken 2072 times.
✗ Branch 8 → 85 not taken.
 2072 auto lhs = std::any_cast<LLVMExprResult>(visit(lhsNode));
619
620
7/8
✓ Branch 10 → 11 taken 893 times.
✓ Branch 10 → 21 taken 21 times.
✓ Branch 10 → 36 taken 7 times.
✓ Branch 10 → 51 taken 747 times.
✓ Branch 10 → 53 taken 5 times.
✓ Branch 10 → 55 taken 225 times.
✓ Branch 10 → 64 taken 174 times.
✗ Branch 10 → 73 not taken.
 2072 switch (node->op) {
621 893 case PrefixUnaryExprNode::PrefixUnaryOp::OP_MINUS: {
622 // Execute operation
623
1/2
✓ Branch 11 → 12 taken 893 times.
✗ Branch 11 → 117 not taken.
 893 lhs = conversionManager.getPrefixMinusInst(node, lhs, lhsSTy);
624
625 // This operator can not work in-place, so we need additional memory
626
1/2
✓ Branch 16 → 17 taken 893 times.
✗ Branch 16 → 88 not taken.
 893 lhs.ptr = insertAlloca(lhs.value->getType());
627
628 // Store the new value
629
1/2
✓ Branch 19 → 20 taken 893 times.
✗ Branch 19 → 117 not taken.
 893 insertStore(lhs.value, lhs.ptr);
630
631 893 break;
632 }
633 21 case PrefixUnaryExprNode::PrefixUnaryOp::OP_PLUS_PLUS: {
634 // Execute operation
635
1/2
✓ Branch 21 → 22 taken 21 times.
✗ Branch 21 → 94 not taken.
 21 lhs.value = conversionManager.getPrefixPlusPlusInst(node, lhs, lhsSTy).value;
636
637 // If this operation happens on a volatile variable, store the value directly
638
3/4
✓ Branch 22 → 23 taken 20 times.
✓ Branch 22 → 25 taken 1 time.
✗ Branch 23 → 24 not taken.
✓ Branch 23 → 25 taken 20 times.
 21 if (lhs.entry && lhs.entry->isVolatile)
639 ✗ insertStore(lhs.value, lhs.ptr, true);
640
641 // Save to the existing address if possible, otherwise (e.g. for literals) allocate new space
642
2/2
✓ Branch 25 → 26 taken 1 time.
✓ Branch 25 → 34 taken 20 times.
 21 if (!lhs.ptr)
643
1/2
✓ Branch 30 → 31 taken 1 time.
✗ Branch 30 → 95 not taken.
 1 lhs.ptr = insertAlloca(lhs.value->getType());
644
645 // Store the new value
646
1/2
✓ Branch 34 → 35 taken 21 times.
✗ Branch 34 → 117 not taken.
 21 insertStore(lhs.value, lhs.ptr);
647
648 21 break;
649 }
650 7 case PrefixUnaryExprNode::PrefixUnaryOp::OP_MINUS_MINUS: {
651 // Execute operation
652
1/2
✓ Branch 36 → 37 taken 7 times.
✗ Branch 36 → 101 not taken.
 7 lhs.value = conversionManager.getPrefixMinusMinusInst(node, lhs, lhsSTy).value;
653
654 // If this operation happens on a volatile variable, store the value directly
655
3/4
✓ Branch 37 → 38 taken 6 times.
✓ Branch 37 → 40 taken 1 time.
✗ Branch 38 → 39 not taken.
✓ Branch 38 → 40 taken 6 times.
 7 if (lhs.entry && lhs.entry->isVolatile)
656 ✗ insertStore(lhs.value, lhs.ptr, true);
657
658 // Save to the existing address if possible, otherwise (e.g. for literals) allocate new space
659
2/2
✓ Branch 40 → 41 taken 1 time.
✓ Branch 40 → 49 taken 6 times.
 7 if (!lhs.ptr)
660
1/2
✓ Branch 45 → 46 taken 1 time.
✗ Branch 45 → 102 not taken.
 1 lhs.ptr = insertAlloca(lhs.value->getType());
661
662 // Store the new value
663
1/2
✓ Branch 49 → 50 taken 7 times.
✗ Branch 49 → 117 not taken.
 7 insertStore(lhs.value, lhs.ptr);
664
665 7 break;
666 }
667 747 case PrefixUnaryExprNode::PrefixUnaryOp::OP_NOT: {
668 // Execute operation
669
1/2
✓ Branch 51 → 52 taken 747 times.
✗ Branch 51 → 117 not taken.
 747 lhs = conversionManager.getPrefixNotInst(node, lhs, lhsSTy);
670 747 break;
671 }
672 5 case PrefixUnaryExprNode::PrefixUnaryOp::OP_BITWISE_NOT: {
673 // Execute operation
674
1/2
✓ Branch 53 → 54 taken 5 times.
✗ Branch 53 → 117 not taken.
 5 lhs = conversionManager.getPrefixBitwiseNotInst(node, lhs, lhsSTy);
675 5 break;
676 }
677 225 case PrefixUnaryExprNode::PrefixUnaryOp::OP_DEREFERENCE: {
678 // If only .refPtr is filled, we can't simply rewire the fields, but need to actually perform a load.
679 // For that we can use resolveValue().
680
4/4
✓ Branch 55 → 56 taken 218 times.
✓ Branch 55 → 58 taken 7 times.
✓ Branch 56 → 57 taken 8 times.
✓ Branch 56 → 58 taken 210 times.
 225 const bool onlyRefPtrIsFilled = lhs.value == nullptr && lhs.ptr == nullptr;
681 // Rewire the fields
682
3/4
✓ Branch 59 → 60 taken 8 times.
✓ Branch 59 → 62 taken 217 times.
✓ Branch 60 → 61 taken 8 times.
✗ Branch 60 → 117 not taken.
 225 llvm::Value *newRefPtr = onlyRefPtrIsFilled ? resolveValue(lhsNode, lhs) : lhs.ptr;
683 225 llvm::Value *newPtr = lhs.value;
684 225 lhs = {.ptr = newPtr, .refPtr = newRefPtr};
685 225 break;
686 }
687 174 case PrefixUnaryExprNode::PrefixUnaryOp::OP_ADDRESS_OF: {
688 // If only .value is filled, we can't simply rewire the fields, but need to actually perform alloca + store.
689 // For that we can use resolveAddress().
690
4/4
✓ Branch 64 → 65 taken 10 times.
✓ Branch 64 → 67 taken 164 times.
✓ Branch 65 → 66 taken 2 times.
✓ Branch 65 → 67 taken 8 times.
 174 const bool onlyValueIsFilled = lhs.ptr == nullptr && lhs.refPtr == nullptr;
691 // Rewire the fields
692
3/4
✓ Branch 68 → 69 taken 2 times.
✓ Branch 68 → 71 taken 172 times.
✓ Branch 69 → 70 taken 2 times.
✗ Branch 69 → 117 not taken.
 174 llvm::Value *newValue = onlyValueIsFilled ? resolveAddress(lhs) : lhs.ptr;
693 174 llvm::Value *newPtr = lhs.refPtr;
694 174 lhs = {.value = newValue, .ptr = newPtr};
695 174 break;
696 }
697 − default: // GCOV_EXCL_LINE
698 − throw CompilerError(UNHANDLED_BRANCH, "PrefixUnaryExpr fall-through"); // GCOV_EXCL_LINE
699 }
700
701
1/2
✓ Branch 81 → 82 taken 2072 times.
✗ Branch 81 → 117 not taken.
 2072 return lhs;
702 }
703
704 116966 std::any IRGenerator::visitPostfixUnaryExpr(const PostfixUnaryExprNode *node) {
705
1/2
✓ Branch 2 → 3 taken 116966 times.
✗ Branch 2 → 241 not taken.
 116966 diGenerator.setSourceLocation(node);
706
707 // If no operator is applied, simply visit the atomic expression
708
2/2
✓ Branch 3 → 4 taken 95195 times.
✓ Branch 3 → 6 taken 21771 times.
 116966 if (node->op == PostfixUnaryExprNode::PostfixUnaryOp::OP_NONE)
709
1/2
✓ Branch 4 → 5 taken 95195 times.
✗ Branch 4 → 241 not taken.
 95195 return visit(node->atomicExpr);
710
711 // Evaluate lhs
712 21771 const PostfixUnaryExprNode *lhsNode = node->postfixUnaryExpr;
713
1/2
✓ Branch 6 → 7 taken 21771 times.
✗ Branch 6 → 241 not taken.
 21771 QualType lhsSTy = lhsNode->getEvaluatedSymbolType(manIdx);
714
2/4
✓ Branch 7 → 8 taken 21771 times.
✗ Branch 7 → 163 not taken.
✓ Branch 8 → 9 taken 21771 times.
✗ Branch 8 → 161 not taken.
 21771 auto lhs = std::any_cast<LLVMExprResult>(visit(lhsNode));
715
716
4/5
✓ Branch 10 → 11 taken 3360 times.
✓ Branch 10 → 62 taken 16209 times.
✓ Branch 10 → 101 taken 1796 times.
✓ Branch 10 → 125 taken 406 times.
✗ Branch 10 → 149 not taken.
 21771 switch (node->op) {
717 3360 case PostfixUnaryExprNode::PostfixUnaryOp::OP_SUBSCRIPT: {
718 3360 const AssignExprNode *indexExpr = node->subscriptIndexExpr;
719
720 // Check if we need to generate a call to an overloaded operator function
721
3/4
✓ Branch 11 → 12 taken 3360 times.
✗ Branch 11 → 199 not taken.
✓ Branch 12 → 13 taken 115 times.
✓ Branch 12 → 29 taken 3245 times.
 3360 if (conversionManager.callsOverloadedOpFct(node, 0)) {
722
1/2
✓ Branch 13 → 14 taken 115 times.
✗ Branch 13 → 164 not taken.
 115 ResolverFct lhsV = [&] { return resolveValue(lhsSTy, lhs); };
723 230 ResolverFct lhsP = [&] { return resolveAddress(lhs); };
724 224 ResolverFct idxV = [&] { return resolveValue(indexExpr); };
725 121 ResolverFct idxP = [&] { return resolveAddress(indexExpr); };
726 115 lhs = conversionManager.callOperatorOverloadFct<2>(node, {lhsV, lhsP, idxV, idxP}, 0);
727 115 break;
728 115 }
729
730
1/2
✓ Branch 29 → 30 taken 3245 times.
✗ Branch 29 → 182 not taken.
 3245 lhsSTy = lhsSTy.removeReferenceWrapper();
731
732 // Get the index value
733
1/2
✓ Branch 30 → 31 taken 3245 times.
✗ Branch 30 → 199 not taken.
 3245 llvm::Value *indexValue = resolveValue(indexExpr);
734 // Come up with the address
735
8/10
✓ Branch 31 → 32 taken 3245 times.
✗ Branch 31 → 199 not taken.
✓ Branch 32 → 33 taken 186 times.
✓ Branch 32 → 36 taken 3059 times.
✓ Branch 33 → 34 taken 186 times.
✗ Branch 33 → 199 not taken.
✓ Branch 34 → 35 taken 145 times.
✓ Branch 34 → 36 taken 41 times.
✓ Branch 37 → 38 taken 145 times.
✓ Branch 37 → 49 taken 3100 times.
 3245 if (lhsSTy.isArray() && lhsSTy.getArraySize() != ARRAY_SIZE_UNKNOWN) { // Array
736 // Make sure the address is present
737
1/2
✓ Branch 38 → 39 taken 145 times.
✗ Branch 38 → 190 not taken.
 145 resolveAddress(lhs);
738
739 // Calculate address of array item
740
1/2
✓ Branch 39 → 40 taken 145 times.
✗ Branch 39 → 190 not taken.
 145 llvm::Type *lhsTy = lhsSTy.toLLVMType(sourceFile);
741
1/2
✓ Branch 40 → 41 taken 145 times.
✗ Branch 40 → 190 not taken.
 145 llvm::Value *indices[2] = {builder.getInt64(0), indexValue};
742
1/2
✓ Branch 45 → 46 taken 145 times.
✗ Branch 45 → 183 not taken.
 145 lhs.ptr = insertInBoundsGEP(lhsTy, lhs.ptr, indices);
743 } else { // Pointer
744 // Now the pointer is the value
745
1/2
✓ Branch 49 → 50 taken 3100 times.
✗ Branch 49 → 199 not taken.
 3100 lhs.ptr = resolveValue(lhsNode, lhs);
746
747
2/4
✓ Branch 50 → 51 taken 3100 times.
✗ Branch 50 → 191 not taken.
✓ Branch 51 → 52 taken 3100 times.
✗ Branch 51 → 191 not taken.
 3100 llvm::Type *lhsTy = lhsSTy.getContained().toLLVMType(sourceFile);
748 // Calculate address of pointer item
749
1/2
✓ Branch 56 → 57 taken 3100 times.
✗ Branch 56 → 192 not taken.
 3100 lhs.ptr = insertInBoundsGEP(lhsTy, lhs.ptr, indexValue);
750 }
751
752 // Reset value and entry
753 3245 lhs.value = nullptr;
754 3245 lhs.entry = nullptr;
755 3245 break;
756 }
757 16209 case PostfixUnaryExprNode::PostfixUnaryOp::OP_MEMBER_ACCESS: {
758 // Get the address of the struct instance
759
1/2
✓ Branch 62 → 63 taken 16209 times.
✗ Branch 62 → 217 not taken.
 16209 resolveAddress(lhs);
760
1/2
✓ Branch 63 → 64 taken 16209 times.
✗ Branch 63 → 200 not taken.
 16209 lhsSTy = lhsSTy.removeReferenceWrapper();
761
762 // Auto de-reference pointer
763
1/2
✓ Branch 64 → 65 taken 16209 times.
✗ Branch 64 → 217 not taken.
 16209 autoDeReferencePtr(lhs.ptr, lhsSTy);
764
2/4
✓ Branch 65 → 66 taken 16209 times.
✗ Branch 65 → 217 not taken.
✗ Branch 66 → 67 not taken.
✓ Branch 66 → 68 taken 16209 times.
 16209 assert(lhsSTy.is(TY_STRUCT));
765
766 // Retrieve struct scope
767 16209 const std::string &fieldName = node->identifier;
768
1/2
✓ Branch 68 → 69 taken 16209 times.
✗ Branch 68 → 217 not taken.
 16209 Scope *structScope = lhsSTy.getBodyScope();
769
770 // Retrieve field entry
771 16209 std::vector<size_t> indexPath;
772
1/2
✓ Branch 69 → 70 taken 16209 times.
✗ Branch 69 → 215 not taken.
 16209 lhs.entry = structScope->symbolTable.lookupInComposedFields(fieldName, indexPath);
773
1/2
✗ Branch 70 → 71 not taken.
✓ Branch 70 → 72 taken 16209 times.
 16209 assert(lhs.entry != nullptr);
774
1/2
✓ Branch 72 → 73 taken 16209 times.
✗ Branch 72 → 215 not taken.
 16209 const QualType fieldSymbolType = lhs.entry->getQualType();
775
776 // Get address of the field in the struct instance
777
2/4
✓ Branch 73 → 74 taken 16209 times.
✗ Branch 73 → 204 not taken.
✓ Branch 76 → 77 taken 16209 times.
✗ Branch 76 → 201 not taken.
 32418 std::vector<llvm::Value *> indices = {builder.getInt64(0)};
778
2/2
✓ Branch 85 → 80 taken 16215 times.
✓ Branch 85 → 86 taken 16209 times.
 32424 for (const size_t index : indexPath)
779
2/4
✓ Branch 81 → 82 taken 16215 times.
✗ Branch 81 → 205 not taken.
✓ Branch 82 → 83 taken 16215 times.
✗ Branch 82 → 205 not taken.
 16215 indices.push_back(builder.getInt32(index));
780
1/2
✓ Branch 86 → 87 taken 16209 times.
✗ Branch 86 → 213 not taken.
 16209 const std::string name = fieldName + ".addr";
781
3/6
✓ Branch 87 → 88 taken 16209 times.
✗ Branch 87 → 210 not taken.
✓ Branch 89 → 90 taken 16209 times.
✗ Branch 89 → 207 not taken.
✓ Branch 90 → 91 taken 16209 times.
✗ Branch 90 → 207 not taken.
 16209 llvm::Value *memberAddr = insertInBoundsGEP(lhsSTy.toLLVMType(sourceFile), lhs.ptr, indices, name);
782
783 // Set as ptr or refPtr, depending on the type
784
3/4
✓ Branch 92 → 93 taken 16209 times.
✗ Branch 92 → 211 not taken.
✓ Branch 93 → 94 taken 203 times.
✓ Branch 93 → 95 taken 16006 times.
 16209 if (fieldSymbolType.isRef()) {
785 203 lhs.ptr = nullptr;
786 203 lhs.refPtr = memberAddr;
787 } else {
788 16006 lhs.ptr = memberAddr;
789 16006 lhs.refPtr = nullptr;
790 }
791
792 // Reset the value
793 16209 lhs.value = nullptr;
794 16209 break;
795 16209 }
796 1796 case PostfixUnaryExprNode::PostfixUnaryOp::OP_PLUS_PLUS: {
797 // Make sure a value is present
798
1/2
✓ Branch 101 → 102 taken 1796 times.
✗ Branch 101 → 224 not taken.
 1796 resolveValue(lhsNode, lhs);
799
800 // Allocate new local variable if required
801
2/2
✓ Branch 102 → 103 taken 2 times.
✓ Branch 102 → 113 taken 1794 times.
 1796 if (!lhs.ptr) {
802
1/2
✗ Branch 103 → 104 not taken.
✓ Branch 103 → 105 taken 2 times.
 2 assert(lhs.value != nullptr);
803
1/2
✓ Branch 109 → 110 taken 2 times.
✗ Branch 109 → 218 not taken.
 2 lhs.ptr = insertAlloca(lhs.value->getType());
804 }
805
806 // Execute operation
807
1/2
✓ Branch 113 → 114 taken 1796 times.
✗ Branch 113 → 224 not taken.
 1796 const LLVMExprResult result = conversionManager.getPostfixPlusPlusInst(node, lhs, lhsSTy);
808
809 // Save the new value to the old address
810
3/4
✓ Branch 114 → 115 taken 1796 times.
✗ Branch 114 → 224 not taken.
✓ Branch 115 → 116 taken 9 times.
✓ Branch 115 → 117 taken 1787 times.
 1796 if (conversionManager.callsOverloadedOpFct(node, 0)) {
811 9 lhs.value = result.value;
812 9 lhs.ptr = result.ptr;
813 } else {
814
5/6
✓ Branch 117 → 118 taken 1784 times.
✓ Branch 117 → 120 taken 3 times.
✓ Branch 118 → 119 taken 3 times.
✓ Branch 118 → 120 taken 1781 times.
✓ Branch 121 → 122 taken 1787 times.
✗ Branch 121 → 224 not taken.
 1787 insertStore(result.value, lhs.ptr, lhs.entry && lhs.entry->isVolatile);
815 1787 lhs.ptr = nullptr;
816 }
817 1796 break;
818 }
819 406 case PostfixUnaryExprNode::PostfixUnaryOp::OP_MINUS_MINUS: {
820 // Make sure a value is present
821
1/2
✓ Branch 125 → 126 taken 406 times.
✗ Branch 125 → 231 not taken.
 406 resolveValue(lhsNode, lhs);
822
823 // Allocate new local variable if required
824
2/2
✓ Branch 126 → 127 taken 2 times.
✓ Branch 126 → 137 taken 404 times.
 406 if (!lhs.ptr) {
825
1/2
✗ Branch 127 → 128 not taken.
✓ Branch 127 → 129 taken 2 times.
 2 assert(lhs.value != nullptr);
826
1/2
✓ Branch 133 → 134 taken 2 times.
✗ Branch 133 → 225 not taken.
 2 lhs.ptr = insertAlloca(lhs.value->getType());
827 }
828
829 // Execute operation
830
1/2
✓ Branch 137 → 138 taken 406 times.
✗ Branch 137 → 231 not taken.
 406 const LLVMExprResult result = conversionManager.getPostfixMinusMinusInst(node, lhs, lhsSTy);
831
832 // Save the new value to the old address
833
3/4
✓ Branch 138 → 139 taken 406 times.
✗ Branch 138 → 231 not taken.
✓ Branch 139 → 140 taken 7 times.
✓ Branch 139 → 141 taken 399 times.
 406 if (conversionManager.callsOverloadedOpFct(node, 0)) {
834 7 lhs.value = result.value;
835 7 lhs.ptr = result.ptr;
836 } else {
837
4/6
✓ Branch 141 → 142 taken 397 times.
✓ Branch 141 → 144 taken 2 times.
✗ Branch 142 → 143 not taken.
✓ Branch 142 → 144 taken 397 times.
✓ Branch 145 → 146 taken 399 times.
✗ Branch 145 → 231 not taken.
 399 insertStore(result.value, lhs.ptr, lhs.entry && lhs.entry->isVolatile);
838 399 lhs.ptr = nullptr;
839 }
840 406 break;
841 }
842 − default: // GCOV_EXCL_LINE
843 − throw CompilerError(UNHANDLED_BRANCH, "PostfixUnaryExpr fall-through"); // GCOV_EXCL_LINE
844 }
845
846
1/2
✓ Branch 157 → 158 taken 21771 times.
✗ Branch 157 → 241 not taken.
 21771 return lhs;
847
5/14
✓ Branch 17 → 18 taken 115 times.
✗ Branch 17 → 167 not taken.
✓ Branch 18 → 19 taken 115 times.
✗ Branch 18 → 167 not taken.
✓ Branch 19 → 20 taken 115 times.
✗ Branch 19 → 167 not taken.
✓ Branch 20 → 21 taken 115 times.
✗ Branch 20 → 167 not taken.
✓ Branch 21 → 22 taken 115 times.
✗ Branch 21 → 165 not taken.
✗ Branch 167 → 168 not taken.
✗ Branch 167 → 171 not taken.
✗ Branch 169 → 170 not taken.
✗ Branch 169 → 171 not taken.
 115 }
848
849 95195 std::any IRGenerator::visitAtomicExpr(const AtomicExprNode *node) {
850
1/2
✓ Branch 2 → 3 taken 95195 times.
✗ Branch 2 → 89 not taken.
 95195 diGenerator.setSourceLocation(node);
851
852 // If constant
853
2/2
✓ Branch 3 → 4 taken 17227 times.
✓ Branch 3 → 10 taken 77968 times.
 95195 if (node->constant) {
854
2/4
✓ Branch 4 → 5 taken 17227 times.
✗ Branch 4 → 81 not taken.
✓ Branch 5 → 6 taken 17227 times.
✗ Branch 5 → 79 not taken.
 17227 const auto constantValue = std::any_cast<llvm::Constant *>(visit(node->constant));
855
1/2
✓ Branch 7 → 8 taken 17227 times.
✗ Branch 7 → 82 not taken.
 34454 return LLVMExprResult{.constant = constantValue};
856 }
857
858 // If value
859
2/2
✓ Branch 10 → 11 taken 18997 times.
✓ Branch 10 → 13 taken 58971 times.
 77968 if (node->value)
860
1/2
✓ Branch 11 → 12 taken 18997 times.
✗ Branch 11 → 89 not taken.
 18997 return visit(node->value);
861
862 // Is assign expression
863
2/2
✓ Branch 13 → 14 taken 581 times.
✓ Branch 13 → 16 taken 58390 times.
 58971 if (node->assignExpr)
864
1/2
✓ Branch 14 → 15 taken 581 times.
✗ Branch 14 → 89 not taken.
 581 return visit(node->assignExpr);
865
866 // Check for builtin calls
867
2/2
✓ Branch 16 → 17 taken 1763 times.
✓ Branch 16 → 19 taken 56627 times.
 58390 if (node->builtinCall)
868
1/2
✓ Branch 17 → 18 taken 1763 times.
✗ Branch 17 → 89 not taken.
 1763 return visit(node->builtinCall);
869
870 // Identifier (local or global variable access)
871
1/2
✗ Branch 20 → 21 not taken.
✓ Branch 20 → 22 taken 56627 times.
 56627 assert(!node->identifierFragments.empty());
872
873 // Get symbol table entry
874
1/2
✓ Branch 22 → 23 taken 56627 times.
✗ Branch 22 → 89 not taken.
 56627 const auto &[entry, accessScope, capture] = node->data.at(manIdx);
875
1/2
✗ Branch 23 → 24 not taken.
✓ Branch 23 → 25 taken 56627 times.
 56627 assert(entry != nullptr);
876
1/2
✗ Branch 25 → 26 not taken.
✓ Branch 25 → 27 taken 56627 times.
 56627 assert(accessScope != nullptr);
877
1/2
✓ Branch 27 → 28 taken 56627 times.
✗ Branch 27 → 89 not taken.
 56627 const QualType varSymbolType = entry->getQualType();
878
1/2
✓ Branch 28 → 29 taken 56627 times.
✗ Branch 28 → 89 not taken.
 56627 llvm::Type *varType = varSymbolType.toLLVMType(sourceFile);
879
880 // Check if external global variable
881
7/8
✓ Branch 29 → 30 taken 1543 times.
✓ Branch 29 → 33 taken 55084 times.
✓ Branch 30 → 31 taken 1543 times.
✗ Branch 30 → 89 not taken.
✓ Branch 31 → 32 taken 77 times.
✓ Branch 31 → 33 taken 1466 times.
✓ Branch 34 → 35 taken 77 times.
✓ Branch 34 → 38 taken 56550 times.
 56627 if (entry->global && accessScope->isImportedBy(rootScope)) {
882 // External global variables need to be declared and allocated in the current module
883
1/2
✓ Branch 36 → 37 taken 77 times.
✗ Branch 36 → 83 not taken.
 77 llvm::Value *varAddress = module->getOrInsertGlobal(entry->name, varType);
884
1/2
✓ Branch 37 → 38 taken 77 times.
✗ Branch 37 → 89 not taken.
 77 entry->updateAddress(varAddress);
885 }
886
887 // Check if enum item
888
2/2
✓ Branch 38 → 39 taken 266 times.
✓ Branch 38 → 50 taken 56361 times.
 56627 if (accessScope->type == ScopeType::ENUM) {
889
1/2
✓ Branch 39 → 40 taken 266 times.
✗ Branch 39 → 41 not taken.
 266 const auto itemNode = spice_pointer_cast<const EnumItemNode *>(entry->declNode);
890
1/2
✓ Branch 46 → 47 taken 266 times.
✗ Branch 46 → 89 not taken.
 266 llvm::Constant *constantItemValue = llvm::ConstantInt::get(varType, itemNode->itemValue);
891
1/2
✓ Branch 47 → 48 taken 266 times.
✗ Branch 47 → 84 not taken.
 532 return LLVMExprResult{.constant = constantItemValue, .entry = entry};
892 }
893
894
1/2
✓ Branch 50 → 51 taken 56361 times.
✗ Branch 50 → 89 not taken.
 56361 llvm::Value *address = entry->getAddress();
895
1/2
✗ Branch 51 → 52 not taken.
✓ Branch 51 → 53 taken 56361 times.
 56361 assert(address != nullptr);
896
897 // If this is a function/procedure reference, return it as value
898
7/8
✓ Branch 53 → 54 taken 1543 times.
✓ Branch 53 → 57 taken 54818 times.
✓ Branch 54 → 55 taken 1543 times.
✗ Branch 54 → 85 not taken.
✓ Branch 55 → 56 taken 8 times.
✓ Branch 55 → 57 taken 1535 times.
✓ Branch 58 → 59 taken 8 times.
✓ Branch 58 → 63 taken 56353 times.
 56361 if (entry->global && varSymbolType.isOneOf({TY_FUNCTION, TY_PROCEDURE})) {
899
1/2
✓ Branch 59 → 60 taken 8 times.
✗ Branch 59 → 89 not taken.
 8 llvm::Value *fatPtr = buildFatFctPtr(nullptr, nullptr, address);
900
1/2
✓ Branch 60 → 61 taken 8 times.
✗ Branch 60 → 86 not taken.
 16 return LLVMExprResult{.ptr = fatPtr, .entry = entry};
901 }
902
903 // Load the address of the referenced variable
904
10/12
✓ Branch 63 → 64 taken 56353 times.
✗ Branch 63 → 89 not taken.
✓ Branch 64 → 65 taken 52900 times.
✓ Branch 64 → 68 taken 3453 times.
✓ Branch 65 → 66 taken 29 times.
✓ Branch 65 → 69 taken 52871 times.
✓ Branch 66 → 67 taken 29 times.
✗ Branch 66 → 89 not taken.
✓ Branch 67 → 68 taken 11 times.
✓ Branch 67 → 69 taken 18 times.
✓ Branch 70 → 71 taken 3464 times.
✓ Branch 70 → 74 taken 52889 times.
 56353 if (varSymbolType.isRef() || (capture && capture->getMode() == BY_REFERENCE))
905
1/2
✓ Branch 71 → 72 taken 3464 times.
✗ Branch 71 → 87 not taken.
 6928 return LLVMExprResult{.refPtr = address, .entry = entry};
906
907
1/2
✓ Branch 74 → 75 taken 52889 times.
✗ Branch 74 → 88 not taken.
 105778 return LLVMExprResult{.ptr = address, .entry = entry};
908 }
909
910 } // namespace spice::compiler
911