summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/ast/cost.h249
-rw-r--r--src/ast_utils.h3
-rw-r--r--src/passes/OptimizeInstructions.cpp46
-rw-r--r--test/passes/optimize-instructions_optimize-level=2.txt260
-rw-r--r--test/passes/optimize-instructions_optimize-level=2.wast263
5 files changed, 820 insertions, 1 deletions
diff --git a/src/ast/cost.h b/src/ast/cost.h
new file mode 100644
index 000000000..151468650
--- /dev/null
+++ b/src/ast/cost.h
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_ast_cost_h
+#define wasm_ast_cost_h
+
+namespace wasm {
+
+// Measure the execution cost of an AST. Very handwave-ey
+
+struct CostAnalyzer : public Visitor<CostAnalyzer, Index> {
+ CostAnalyzer(Expression *ast) {
+ assert(ast);
+ cost = visit(ast);
+ }
+
+ Index cost;
+
+ Index maybeVisit(Expression* curr) {
+ return curr ? visit(curr) : 0;
+ }
+
+ Index visitBlock(Block *curr) {
+ Index ret = 0;
+ for (auto* child : curr->list) ret += visit(child);
+ return ret;
+ }
+ Index visitIf(If *curr) {
+ return 1 + visit(curr->condition) + std::max(visit(curr->ifTrue), maybeVisit(curr->ifFalse));
+ }
+ Index visitLoop(Loop *curr) {
+ return 5 * visit(curr->body);
+ }
+ Index visitBreak(Break *curr) {
+ return 1 + maybeVisit(curr->value) + maybeVisit(curr->condition);
+ }
+ Index visitSwitch(Switch *curr) {
+ return 2 + visit(curr->condition) + maybeVisit(curr->value);
+ }
+ Index visitCall(Call *curr) {
+ Index ret = 4;
+ for (auto* child : curr->operands) ret += visit(child);
+ return ret;
+ }
+ Index visitCallImport(CallImport *curr) {
+ Index ret = 15;
+ for (auto* child : curr->operands) ret += visit(child);
+ return ret;
+ }
+ Index visitCallIndirect(CallIndirect *curr) {
+ Index ret = 6 + visit(curr->target);
+ for (auto* child : curr->operands) ret += visit(child);
+ return ret;
+ }
+ Index visitGetLocal(GetLocal *curr) {
+ return 0;
+ }
+ Index visitSetLocal(SetLocal *curr) {
+ return 1;
+ }
+ Index visitGetGlobal(GetGlobal *curr) {
+ return 1;
+ }
+ Index visitSetGlobal(SetGlobal *curr) {
+ return 2;
+ }
+ Index visitLoad(Load *curr) {
+ return 1 + visit(curr->ptr);
+ }
+ Index visitStore(Store *curr) {
+ return 2 + visit(curr->ptr) + visit(curr->value);
+ }
+ Index visitConst(Const *curr) {
+ return 1;
+ }
+ Index visitUnary(Unary *curr) {
+ Index ret = 0;
+ switch (curr->op) {
+ case ClzInt32:
+ case CtzInt32:
+ case PopcntInt32:
+ case NegFloat32:
+ case AbsFloat32:
+ case CeilFloat32:
+ case FloorFloat32:
+ case TruncFloat32:
+ case NearestFloat32:
+ case ClzInt64:
+ case CtzInt64:
+ case PopcntInt64:
+ case NegFloat64:
+ case AbsFloat64:
+ case CeilFloat64:
+ case FloorFloat64:
+ case TruncFloat64:
+ case NearestFloat64:
+ case EqZInt32:
+ case EqZInt64:
+ case ExtendSInt32:
+ case ExtendUInt32:
+ case WrapInt64:
+ case PromoteFloat32:
+ case DemoteFloat64:
+ case TruncSFloat32ToInt32:
+ case TruncUFloat32ToInt32:
+ case TruncSFloat64ToInt32:
+ case TruncUFloat64ToInt32:
+ case ReinterpretFloat32:
+ case TruncSFloat32ToInt64:
+ case TruncUFloat32ToInt64:
+ case TruncSFloat64ToInt64:
+ case TruncUFloat64ToInt64:
+ case ReinterpretFloat64:
+ case ReinterpretInt32:
+ case ConvertSInt32ToFloat32:
+ case ConvertUInt32ToFloat32:
+ case ConvertSInt64ToFloat32:
+ case ConvertUInt64ToFloat32:
+ case ReinterpretInt64:
+ case ConvertSInt32ToFloat64:
+ case ConvertUInt32ToFloat64:
+ case ConvertSInt64ToFloat64:
+ case ConvertUInt64ToFloat64: ret = 1; break;
+ case SqrtFloat32:
+ case SqrtFloat64: ret = 2; break;
+ default: WASM_UNREACHABLE();
+ }
+ return ret + visit(curr->value);
+ }
+ Index visitBinary(Binary *curr) {
+ Index ret = 0;
+ switch (curr->op) {
+ case AddInt32: ret = 1; break;
+ case SubInt32: ret = 1; break;
+ case MulInt32: ret = 2; break;
+ case DivSInt32: ret = 3; break;
+ case DivUInt32: ret = 3; break;
+ case RemSInt32: ret = 3; break;
+ case RemUInt32: ret = 3; break;
+ case AndInt32: ret = 1; break;
+ case OrInt32: ret = 1; break;
+ case XorInt32: ret = 1; break;
+ case ShlInt32: ret = 1; break;
+ case ShrUInt32: ret = 1; break;
+ case ShrSInt32: ret = 1; break;
+ case RotLInt32: ret = 1; break;
+ case RotRInt32: ret = 1; break;
+ case AddInt64: ret = 1; break;
+ case SubInt64: ret = 1; break;
+ case MulInt64: ret = 2; break;
+ case DivSInt64: ret = 3; break;
+ case DivUInt64: ret = 3; break;
+ case RemSInt64: ret = 3; break;
+ case RemUInt64: ret = 3; break;
+ case AndInt64: ret = 1; break;
+ case OrInt64: ret = 1; break;
+ case XorInt64: ret = 1; break;
+ case ShlInt64: ret = 1; break;
+ case ShrUInt64: ret = 1; break;
+ case ShrSInt64: ret = 1; break;
+ case RotLInt64: ret = 1; break;
+ case RotRInt64: ret = 1; break;
+ case AddFloat32: ret = 1; break;
+ case SubFloat32: ret = 1; break;
+ case MulFloat32: ret = 2; break;
+ case DivFloat32: ret = 3; break;
+ case CopySignFloat32: ret = 1; break;
+ case MinFloat32: ret = 1; break;
+ case MaxFloat32: ret = 1; break;
+ case AddFloat64: ret = 1; break;
+ case SubFloat64: ret = 1; break;
+ case MulFloat64: ret = 2; break;
+ case DivFloat64: ret = 3; break;
+ case CopySignFloat64: ret = 1; break;
+ case MinFloat64: ret = 1; break;
+ case MaxFloat64: ret = 1; break;
+ case LtUInt32: ret = 1; break;
+ case LtSInt32: ret = 1; break;
+ case LeUInt32: ret = 1; break;
+ case LeSInt32: ret = 1; break;
+ case GtUInt32: ret = 1; break;
+ case GtSInt32: ret = 1; break;
+ case GeUInt32: ret = 1; break;
+ case GeSInt32: ret = 1; break;
+ case LtUInt64: ret = 1; break;
+ case LtSInt64: ret = 1; break;
+ case LeUInt64: ret = 1; break;
+ case LeSInt64: ret = 1; break;
+ case GtUInt64: ret = 1; break;
+ case GtSInt64: ret = 1; break;
+ case GeUInt64: ret = 1; break;
+ case GeSInt64: ret = 1; break;
+ case LtFloat32: ret = 1; break;
+ case GtFloat32: ret = 1; break;
+ case LeFloat32: ret = 1; break;
+ case GeFloat32: ret = 1; break;
+ case LtFloat64: ret = 1; break;
+ case GtFloat64: ret = 1; break;
+ case LeFloat64: ret = 1; break;
+ case GeFloat64: ret = 1; break;
+ case EqInt32: ret = 1; break;
+ case NeInt32: ret = 1; break;
+ case EqInt64: ret = 1; break;
+ case NeInt64: ret = 1; break;
+ case EqFloat32: ret = 1; break;
+ case NeFloat32: ret = 1; break;
+ case EqFloat64: ret = 1; break;
+ case NeFloat64: ret = 1; break;
+ default: WASM_UNREACHABLE();
+ }
+ return ret + visit(curr->left) + visit(curr->right);
+ }
+ Index visitSelect(Select *curr) {
+ return 2 + visit(curr->condition) + visit(curr->ifTrue) + visit(curr->ifFalse);
+ }
+ Index visitDrop(Drop *curr) {
+ return visit(curr->value);
+ }
+ Index visitReturn(Return *curr) {
+ return maybeVisit(curr->value);
+ }
+ Index visitHost(Host *curr) {
+ return 100;
+ }
+ Index visitNop(Nop *curr) {
+ return 0;
+ }
+ Index visitUnreachable(Unreachable *curr) {
+ return 0;
+ }
+};
+
+} // namespace wasm
+
+#endif // wasm_ast_cost_h
+
diff --git a/src/ast_utils.h b/src/ast_utils.h
index 861a09aaf..9dfacb972 100644
--- a/src/ast_utils.h
+++ b/src/ast_utils.h
@@ -209,7 +209,8 @@ struct EffectAnalyzer : public PostWalker<EffectAnalyzer, Visitor<EffectAnalyzer
void visitUnreachable(Unreachable *curr) { branches = true; }
};
-// Meausure the size of an AST
+// Measure the size of an AST
+
struct Measurer : public PostWalker<Measurer, UnifiedExpressionVisitor<Measurer>> {
Index size = 0;
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index a5c665458..84f126ae9 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -25,6 +25,7 @@
#include <wasm-s-parser.h>
#include <support/threads.h>
#include <ast_utils.h>
+#include <ast/cost.h>
#include <ast/properties.h>
namespace wasm {
@@ -251,6 +252,9 @@ struct OptimizeInstructions : public WalkerPass<PostWalker<OptimizeInstructions,
}
}
}
+ return conditionalizeExpensiveOnBitwise(binary);
+ } else if (binary->op == OrInt32) {
+ return conditionalizeExpensiveOnBitwise(binary);
}
} else if (auto* unary = curr->dynCast<Unary>()) {
// de-morgan's laws
@@ -360,6 +364,48 @@ private:
}
return boolean;
}
+
+ // expensive1 | expensive2 can be turned into expensive1 ? 1 : expensive2, and
+ // expensive | cheap can be turned into cheap ? 1 : expensive,
+ // so that we can avoid one expensive computation, if it has no side effects.
+ Expression* conditionalizeExpensiveOnBitwise(Binary* binary) {
+ // this operation can increase code size, so don't always do it
+ auto& options = getPassRunner()->options;
+ if (options.optimizeLevel < 2 || options.shrinkLevel > 0) return nullptr;
+ const auto MIN_COST = 7;
+ assert(binary->op == AndInt32 || binary->op == OrInt32);
+ if (binary->right->is<Const>()) return nullptr; // trivial
+ // bitwise logical operator on two non-numerical values, check if they are boolean
+ auto* left = binary->left;
+ auto* right = binary->right;
+ if (!Properties::emitsBoolean(left) || !Properties::emitsBoolean(right)) return nullptr;
+ auto leftEffects = EffectAnalyzer(left).hasSideEffects();
+ auto rightEffects = EffectAnalyzer(right).hasSideEffects();
+ if (leftEffects && rightEffects) return nullptr; // both must execute
+ // canonicalize with side effects, if any, happening on the left
+ if (rightEffects) {
+ if (CostAnalyzer(left).cost < MIN_COST) return nullptr; // avoidable code is too cheap
+ std::swap(left, right);
+ } else if (leftEffects) {
+ if (CostAnalyzer(right).cost < MIN_COST) return nullptr; // avoidable code is too cheap
+ } else {
+ // no side effects, reorder based on cost estimation
+ auto leftCost = CostAnalyzer(left).cost;
+ auto rightCost = CostAnalyzer(right).cost;
+ if (std::max(leftCost, rightCost) < MIN_COST) return nullptr; // avoidable code is too cheap
+ // canonicalize with expensive code on the right
+ if (leftCost > rightCost) {
+ std::swap(left, right);
+ }
+ }
+ // worth it! perform conditionalization
+ Builder builder(*getModule());
+ if (binary->op == OrInt32) {
+ return builder.makeIf(left, builder.makeConst(Literal(int32_t(1))), right);
+ } else { // &
+ return builder.makeIf(left, right, builder.makeConst(Literal(int32_t(0))));
+ }
+ }
};
Pass *createOptimizeInstructionsPass() {
diff --git a/test/passes/optimize-instructions_optimize-level=2.txt b/test/passes/optimize-instructions_optimize-level=2.txt
new file mode 100644
index 000000000..243421e8c
--- /dev/null
+++ b/test/passes/optimize-instructions_optimize-level=2.txt
@@ -0,0 +1,260 @@
+(module
+ (type $0 (func (param i32 i32) (result i32)))
+ (memory $0 0)
+ (func $conditionals (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (if i32
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (tee_local $7
+ (i32.add
+ (get_local $0)
+ (i32.const 2)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ (i32.eqz
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (i32.const 11)
+ )
+ (i32.const 3)
+ )
+ )
+ (i32.const 1)
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+ (func $side-effect (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (i32.or
+ (i32.eqz
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (tee_local $7
+ (i32.add
+ (get_local $0)
+ (i32.const 0)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ )
+ (i32.eqz
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (unreachable)
+ )
+ (i32.const 3)
+ )
+ )
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+ (func $flip (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (if i32
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (i32.const 100)
+ )
+ (i32.const 3)
+ )
+ (i32.eqz
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (i32.eqz
+ (i32.add
+ (get_local $0)
+ (i32.const 0)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ )
+ (i32.const 1)
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+)
diff --git a/test/passes/optimize-instructions_optimize-level=2.wast b/test/passes/optimize-instructions_optimize-level=2.wast
new file mode 100644
index 000000000..7874907f3
--- /dev/null
+++ b/test/passes/optimize-instructions_optimize-level=2.wast
@@ -0,0 +1,263 @@
+(module
+ (type $0 (func (param i32 i32) (result i32)))
+ (memory $0 0)
+ (func $conditionals (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (i32.or ;; this or is very expensive. we should compute one side, then see if we even need the other
+ (i32.eqz
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (tee_local $7 ;; side effect, so we can't do this one
+ (i32.add
+ (get_local $0)
+ (i32.const 2)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ )
+ (i32.eqz
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (i32.const 11)
+ )
+ (i32.const 3)
+ )
+ )
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+ (func $side-effect (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (i32.or ;; this or is very expensive, but has a side effect on both sides
+ (i32.eqz
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (tee_local $7
+ (i32.add
+ (get_local $0)
+ (i32.const 0)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ )
+ (i32.eqz
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (unreachable)
+ )
+ (i32.const 3)
+ )
+ )
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+ (func $flip (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (local $2 i32)
+ (local $3 i32)
+ (local $4 i32)
+ (local $5 i32)
+ (local $6 i32)
+ (local $7 i32)
+ (set_local $0
+ (i32.const 0)
+ )
+ (loop $while-in
+ (set_local $3
+ (i32.const 0)
+ )
+ (loop $while-in6
+ (set_local $6
+ (i32.add
+ (get_local $0)
+ (i32.const 1)
+ )
+ )
+ (set_local $0
+ (if i32
+ (i32.or ;; this or is very expensive, and the first side has no side effect
+ (i32.eqz
+ (i32.rem_s
+ (i32.add
+ (i32.mul
+ (i32.eqz
+ (i32.add
+ (get_local $0)
+ (i32.const 0)
+ )
+ )
+ (get_local $0)
+ )
+ (i32.const 17)
+ )
+ (i32.const 5)
+ )
+ )
+ (i32.eqz
+ (i32.rem_u
+ (i32.add
+ (i32.mul
+ (get_local $0)
+ (get_local $0)
+ )
+ (i32.const 100)
+ )
+ (i32.const 3)
+ )
+ )
+ )
+ (get_local $7)
+ (get_local $6)
+ )
+ )
+ (br_if $while-in6
+ (i32.lt_s
+ (tee_local $3
+ (i32.add
+ (get_local $3)
+ (i32.const 1)
+ )
+ )
+ (get_local $4)
+ )
+ )
+ )
+ (br_if $while-in
+ (i32.ne
+ (tee_local $1
+ (i32.add
+ (get_local $1)
+ (i32.const 1)
+ )
+ )
+ (i32.const 27000)
+ )
+ )
+ )
+ (return
+ (get_local $5)
+ )
+ )
+)
+
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-05 21:02:53 +0000