Address comments
diff --git a/src/analysis/bits-bounds-lattice.h b/src/analysis/bits-bounds-lattice.h
index f2f334d..cebddfc 100644
--- a/src/analysis/bits-bounds-lattice.h
+++ b/src/analysis/bits-bounds-lattice.h
@@ -1,7 +1,24 @@
+/*
+ * Copyright 2023 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_analysis_bits_bounds_lattice_h
#define wasm_analysis_bits_bounds_lattice_h
#include <optional>
+#include <variant>
#include "lattice.h"
#include "wasm.h"
@@ -9,67 +26,129 @@
namespace wasm::analysis {
struct MaxBitsLattice {
- enum LatticeState { BOTTOM, REGULAR_VALUE, TOP };
+ enum LatticeState { BOTTOM, TOP };
- struct Element {
- Index upperBound = 0;
- std::optional<Literal> constVal;
- LatticeState state = BOTTOM;
+ class Element {
+ // If this holds a LatticeState, it indicates if the element is a top or
+ // bottom element. An Index will represent the maximum number of bits a
+ // value has. A Literal contains the actual value if we know what it is.
+ std::variant<Index, Literal, LatticeState> value;
- bool isTop() const { return state == TOP; }
+ public:
+ bool isTop() const {
+ if (std::holds_alternative<LatticeState>(value)) {
+ return std::get<LatticeState>(value) == LatticeState::TOP;
+ }
+ return false;
+ }
- bool isBottom() const { return state == BOTTOM; }
+ void setTop() { value = LatticeState::TOP; }
- void setUpperBound(Index upperBound) {
- if (state != TOP) {
- state = REGULAR_VALUE;
- this->upperBound = upperBound;
- constVal.reset();
+ bool isBottom() const {
+ if (std::holds_alternative<LatticeState>(value)) {
+ return std::get<LatticeState>(value) == LatticeState::BOTTOM;
+ }
+ return false;
+ }
+
+ void setBottom() { value = LatticeState::BOTTOM; }
+
+ // Returns an optional which contains a literal (i.e. constant)
+ // value if it exists.
+ std::optional<Literal> getLiteral() const {
+ std::optional<Literal> result;
+ if (std::holds_alternative<Literal>(value)) {
+ result = std::get<Literal>(value);
+ }
+ return result;
+ }
+
+ // Returns the maximum number of bits. The optional is empty
+ // for the top and bottom elements, or if the literal happens
+ // not to be i32 or i64.
+ std::optional<Index> getUpperBound() const {
+ std::optional<Index> result;
+ if (std::holds_alternative<Index>(value)) {
+ result = std::get<Index>(value);
+ } else if (std::holds_alternative<Literal>(value)) {
+ Literal val = std::get<Literal>(value);
+ if (val.type == Type::i32) {
+ result = 32 - val.countLeadingZeroes().geti32();
+ } else if (val.type == Type::i64) {
+ result = 64 - val.countLeadingZeroes().geti64();
+ }
+ }
+ return result;
+ }
+
+ // Returns an upper bound approximated for i32s. If Top, returns 32. If
+ // bottom, or has no upper bound, returns 0.
+ Index geti32ApproxUpperBound() const {
+ std::optional<Index> result = getUpperBound();
+ if (result.has_value()) {
+ return result.value();
+ } else if (isTop()) {
+ return Index(32);
+ } else {
+ return Index(0);
}
}
- void setUpperBound(Index upperBound, Literal constVal) {
- if (state != TOP) {
- state = REGULAR_VALUE;
- this->upperBound = upperBound;
- this->constVal = constVal;
+ // Returns an upper bound approximated of i64s. If Top, returns 32. If
+ // bottom, or has no upper bound, returns 0.
+ Index geti64ApproxUpperBound() const {
+ std::optional<Index> result = getUpperBound();
+ if (result.has_value()) {
+ return result.value();
+ } else if (isTop()) {
+ return Index(64);
+ } else {
+ return Index(0);
}
}
- void setTop() {
- state = TOP;
- upperBound = UINT32_MAX;
- constVal.reset();
+ void setUpperBound(Index upperBound) { value = upperBound; }
+
+ // If we don't have a desired literal type, we switch to
+ // bottom (i.e. the literal isn't supposed to have a max bits value).
+ void setLiteralValue(Literal val) {
+ if (val.type == Type::i32 || val.type == Type::i64) {
+ value = val;
+ } else {
+ value = LatticeState::BOTTOM;
+ }
}
bool makeLeastUpperBound(const Element& other) {
if (other.isBottom() || isTop()) {
return false;
} else if (other.isTop()) {
- setTop();
+ value = LatticeState::TOP;
return true;
} else if (isBottom()) {
- if (other.constVal.has_value()) {
- setUpperBound(other.upperBound, other.constVal.value());
+ if (std::holds_alternative<Literal>(other.value)) {
+ value = std::get<Literal>(other.value);
} else {
- setUpperBound(other.upperBound);
+ value = std::get<Index>(other.value);
}
return true;
}
- if (upperBound < other.upperBound) {
- if (other.constVal.has_value()) {
- setUpperBound(other.upperBound, other.constVal.value());
+ Index currMaxBits = getUpperBound().value();
+ Index otherMaxBits = other.getUpperBound().value();
+
+ if (currMaxBits < otherMaxBits) {
+ if (std::holds_alternative<Literal>(other.value)) {
+ value = std::get<Literal>(other.value);
} else {
- setUpperBound(other.upperBound);
+ value = otherMaxBits;
}
return true;
- } else if (upperBound == other.upperBound && other.constVal.has_value()) {
- if (constVal.has_value()) {
- constVal.reset();
- } else {
- constVal = other.constVal.value();
- }
+ } else if (currMaxBits == otherMaxBits &&
+ std::holds_alternative<Literal>(value) &&
+ (!std::holds_alternative<Literal>(other.value) ||
+ std::get<Literal>(value) != std::get<Literal>(other.value))) {
+ value = currMaxBits;
return true;
}
@@ -77,15 +156,16 @@
}
void print(std::ostream& os) {
- if (state == TOP) {
- os << "TOP";
- } else if (state == BOTTOM) {
- os << "BOTTOM";
- } else {
- os << upperBound;
- if (constVal.has_value()) {
- os << " " << constVal.value();
+ if (LatticeState* val = std::get_if<LatticeState>(&value)) {
+ if (*val == LatticeState::BOTTOM) {
+ os << "BOTTOM";
+ } else {
+ os << "TOP";
}
+ } else if (Index* val = std::get_if<Index>(&value)) {
+ os << *val;
+ } else {
+ os << "Literal " << std::get<Literal>(value);
}
}
@@ -93,32 +173,38 @@
};
LatticeComparison compare(const Element& left, const Element& right) {
- if (left.isTop()) {
- if (right.isTop()) {
- return LatticeComparison::EQUAL;
+ if (std::holds_alternative<LatticeState>(left.value)) {
+ LatticeState leftVal = std::get<LatticeState>(left.value);
+ if (std::holds_alternative<LatticeState>(right.value)) {
+ LatticeState rightVal = std::get<LatticeState>(right.value);
+ if (leftVal < rightVal) {
+ return LatticeComparison::LESS;
+ } else if (leftVal > rightVal) {
+ return LatticeComparison::GREATER;
+ } else {
+ return LatticeComparison::EQUAL;
+ }
} else {
- return LatticeComparison::GREATER;
+ return leftVal == LatticeState::TOP ? LatticeComparison::GREATER
+ : LatticeComparison::LESS;
}
- } else if (right.isTop()) {
- return LatticeComparison::LESS;
- } else if (left.isBottom()) {
- if (right.isBottom()) {
- return LatticeComparison::EQUAL;
- } else {
- return LatticeComparison::LESS;
- }
- } else if (right.isBottom()) {
- return LatticeComparison::GREATER;
+ } else if (std::holds_alternative<LatticeState>(right.value)) {
+ return std::get<LatticeState>(right.value) == LatticeState::TOP
+ ? LatticeComparison::LESS
+ : LatticeComparison::GREATER;
}
- if (left.upperBound > right.upperBound) {
- return LatticeComparison::GREATER;
- } else if (left.upperBound < right.upperBound) {
+ Index leftMaxBits = left.getUpperBound().value();
+ Index rightMaxBits = right.getUpperBound().value();
+
+ if (leftMaxBits < rightMaxBits) {
return LatticeComparison::LESS;
+ } else if (leftMaxBits > rightMaxBits) {
+ return LatticeComparison::GREATER;
} else {
- if (left.constVal.has_value()) {
- if (right.constVal.has_value()) {
- if (left.constVal.value() == right.constVal.value()) {
+ if (std::holds_alternative<Literal>(left.value)) {
+ if (std::holds_alternative<Literal>(right.value)) {
+ if (std::get<Literal>(left.value) == std::get<Literal>(right.value)) {
return LatticeComparison::EQUAL;
} else {
return LatticeComparison::NO_RELATION;
@@ -127,7 +213,7 @@
return LatticeComparison::LESS;
}
} else {
- if (right.constVal.has_value()) {
+ if (std::holds_alternative<Literal>(right.value)) {
return LatticeComparison::GREATER;
} else {
return LatticeComparison::EQUAL;
diff --git a/src/analysis/bits-bounds-transfer-function.h b/src/analysis/bits-bounds-transfer-function.h
index c5e53cf..49a5d0d 100644
--- a/src/analysis/bits-bounds-transfer-function.h
+++ b/src/analysis/bits-bounds-transfer-function.h
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2023 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_analysis_bits_bounds_transfer_function_h
#define wasm_analysis_bits_bounds_transfer_function_h
@@ -26,25 +42,22 @@
void visitConst(Const* curr) {
MaxBitsLattice::Element currElement = bitsLattice.getBottom();
- bool addInformation = true;
switch (curr->type.getBasic()) {
case Type::i32:
- currElement.setUpperBound(
- 32 - curr->value.countLeadingZeroes().geti32(), curr->value);
+ currElement.setLiteralValue(curr->value);
+ if (collectingResults) {
+ exprMaxBounds[curr] = currElement.getUpperBound().value();
+ }
break;
case Type::i64:
- currElement.setUpperBound(
- 64 - curr->value.countLeadingZeroes().geti64(), curr->value);
+ currElement.setLiteralValue(curr->value);
+ if (collectingResults) {
+ exprMaxBounds[curr] = currElement.getUpperBound().value();
+ }
break;
default: {
- addInformation = false;
}
}
-
- if (collectingResults && addInformation) {
- exprMaxBounds[curr] = currElement.upperBound;
- }
-
currState->push(std::move(currElement));
}
@@ -59,22 +72,27 @@
case RotLInt32:
case RotRInt32:
case SubInt32: {
+ // TODO: Use a more precise estimate for these cases.
currElement.setUpperBound(32);
break;
}
case AddInt32: {
currElement.setUpperBound(
- std::min(Index(32), std::max(left.upperBound, right.upperBound) + 1));
+ std::min(Index(32),
+ std::max(left.geti32ApproxUpperBound(),
+ right.geti32ApproxUpperBound()) +
+ 1));
break;
}
case MulInt32: {
- currElement.setUpperBound(
- std::min(Index(32), left.upperBound + right.upperBound));
+ currElement.setUpperBound(std::min(Index(32),
+ left.geti32ApproxUpperBound() +
+ right.geti32ApproxUpperBound()));
break;
}
case DivSInt32: {
- int32_t maxBitsLeft = left.upperBound;
- int32_t maxBitsRight = right.upperBound;
+ int32_t maxBitsLeft = left.geti32ApproxUpperBound();
+ int32_t maxBitsRight = right.geti32ApproxUpperBound();
if (maxBitsLeft == 32 || maxBitsRight == 32) {
currElement.setUpperBound(32);
} else {
@@ -84,19 +102,21 @@
break;
}
case DivUInt32: {
- int32_t maxBitsLeft = left.upperBound;
- int32_t maxBitsRight = right.upperBound;
+ int32_t maxBitsLeft = left.geti32ApproxUpperBound();
+ int32_t maxBitsRight = right.geti32ApproxUpperBound();
currElement.setUpperBound(std::max(0, maxBitsLeft - maxBitsRight + 1));
break;
}
case RemSInt32: {
- if (right.constVal.has_value()) {
- if (left.upperBound == 32) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
+ Index leftUpperBound = left.geti32ApproxUpperBound();
+ if (leftUpperBound == 32) {
currElement.setUpperBound(32);
} else {
auto bitsRight =
- Index(wasm::Bits::ceilLog2(right.constVal.value().geti32()));
- currElement.setUpperBound(std::min(left.upperBound, bitsRight));
+ Index(wasm::Bits::ceilLog2(constRightValue.value().geti32()));
+ currElement.setUpperBound(std::min(leftUpperBound, bitsRight));
}
} else {
currElement.setUpperBound(32);
@@ -104,56 +124,67 @@
break;
}
case RemUInt32: {
- if (right.constVal.has_value()) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
auto bitsRight =
- Index(wasm::Bits::ceilLog2(right.constVal.value().geti32()));
- currElement.setUpperBound(std::min(left.upperBound, bitsRight));
+ Index(wasm::Bits::ceilLog2(constRightValue.value().geti32()));
+ currElement.setUpperBound(
+ std::min(left.geti32ApproxUpperBound(), bitsRight));
} else {
currElement.setUpperBound(32);
}
break;
}
case AndInt32: {
- currElement.setUpperBound(std::min(left.upperBound, right.upperBound));
+ currElement.setUpperBound(std::min(left.geti32ApproxUpperBound(),
+ right.geti32ApproxUpperBound()));
break;
}
case OrInt32:
case XorInt32: {
- currElement.setUpperBound(std::max(left.upperBound, right.upperBound));
+ currElement.setUpperBound(std::max(left.geti32ApproxUpperBound(),
+ right.geti32ApproxUpperBound()));
break;
}
case ShlInt32: {
- if (right.constVal.has_value()) {
- currElement.setUpperBound(std::min(
- Index(32),
- left.upperBound + Bits::getEffectiveShifts(
- right.constVal.value().geti32(), Type::i32)));
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
+ currElement.setUpperBound(
+ std::min(Index(32),
+ left.geti32ApproxUpperBound() +
+ Bits::getEffectiveShifts(
+ constRightValue.value().geti32(), Type::i32)));
}
break;
}
case ShrUInt32: {
- if (right.constVal.has_value()) {
- auto shifts = std::min(Index(Bits::getEffectiveShifts(
- right.constVal.value().geti32(), Type::i32)),
- left.upperBound);
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
+ Index leftUpperBound = left.geti32ApproxUpperBound();
+ auto shifts =
+ std::min(Index(Bits::getEffectiveShifts(
+ constRightValue.value().geti32(), Type::i32)),
+ leftUpperBound);
currElement.setUpperBound(
- std::max(Index(0), left.upperBound - shifts));
+ std::max(Index(0), leftUpperBound - shifts));
} else {
currElement.setUpperBound(32);
}
break;
}
case ShrSInt32: {
- if (right.constVal.has_value()) {
- if (left.upperBound == 32) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ Index leftUpperBound = left.geti32ApproxUpperBound();
+ if (constRightValue.has_value()) {
+ if (leftUpperBound == 32) {
currElement.setUpperBound(32);
} else {
auto shifts =
std::min(Index(Bits::getEffectiveShifts(
- right.constVal.value().geti32(), Type::i32)),
- left.upperBound);
+ constRightValue.value().geti32(), Type::i32)),
+ leftUpperBound);
currElement.setUpperBound(
- std::max(Index(0), left.upperBound - shifts));
+ std::max(Index(0), leftUpperBound - shifts));
}
} else {
currElement.setUpperBound(32);
@@ -168,17 +199,20 @@
}
case AddInt64: {
currElement.setUpperBound(
- std::min(Index(64), std::max(left.upperBound, right.upperBound)));
+ std::min(Index(64),
+ std::max(left.geti64ApproxUpperBound(),
+ right.geti64ApproxUpperBound())));
break;
}
case MulInt64: {
- currElement.setUpperBound(
- std::min(Index(64), left.upperBound + right.upperBound));
+ currElement.setUpperBound(std::min(Index(64),
+ left.geti64ApproxUpperBound() +
+ right.geti64ApproxUpperBound()));
break;
}
case DivSInt64: {
- int32_t maxBitsLeft = left.upperBound;
- int32_t maxBitsRight = right.upperBound;
+ int32_t maxBitsLeft = left.geti64ApproxUpperBound();
+ int32_t maxBitsRight = right.geti64ApproxUpperBound();
if (maxBitsLeft == 64 || maxBitsRight == 64) {
currElement.setUpperBound(64);
} else {
@@ -188,19 +222,21 @@
break;
}
case DivUInt64: {
- int32_t maxBitsLeft = left.upperBound;
- int32_t maxBitsRight = right.upperBound;
+ int32_t maxBitsLeft = left.geti64ApproxUpperBound();
+ int32_t maxBitsRight = right.geti64ApproxUpperBound();
currElement.setUpperBound(std::max(0, maxBitsLeft - maxBitsRight + 1));
break;
}
case RemSInt64: {
- if (right.constVal.has_value()) {
- if (left.upperBound == 64) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ Index leftUpperBound = left.geti64ApproxUpperBound();
+ if (constRightValue.has_value()) {
+ if (leftUpperBound == 64) {
currElement.setUpperBound(64);
} else {
auto bitsRight =
- Index(wasm::Bits::ceilLog2(right.constVal.value().geti64()));
- currElement.setUpperBound(std::min(left.upperBound, bitsRight));
+ Index(wasm::Bits::ceilLog2(constRightValue.value().geti64()));
+ currElement.setUpperBound(std::min(leftUpperBound, bitsRight));
}
} else {
currElement.setUpperBound(64);
@@ -208,59 +244,69 @@
break;
}
case RemUInt64: {
- if (right.constVal.has_value()) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
auto bitsRight =
- Index(wasm::Bits::ceilLog2(right.constVal.value().geti64()));
- currElement.setUpperBound(std::min(left.upperBound, bitsRight));
+ Index(wasm::Bits::ceilLog2(constRightValue.value().geti64()));
+ currElement.setUpperBound(
+ std::min(left.geti64ApproxUpperBound(), bitsRight));
} else {
currElement.setUpperBound(64);
}
break;
}
case AndInt64: {
- currElement.setUpperBound(std::min(left.upperBound, right.upperBound));
+ currElement.setUpperBound(std::min(left.geti64ApproxUpperBound(),
+ right.geti64ApproxUpperBound()));
break;
}
case OrInt64:
case XorInt64: {
- currElement.setUpperBound(std::max(left.upperBound, right.upperBound));
+ currElement.setUpperBound(std::max(left.geti64ApproxUpperBound(),
+ right.geti64ApproxUpperBound()));
break;
}
case ShlInt64: {
- if (right.constVal.has_value()) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
currElement.setUpperBound(
std::min(Index(64),
- Bits::getEffectiveShifts(right.constVal.value().geti64(),
+ Bits::getEffectiveShifts(constRightValue.value().geti64(),
Type::i64) +
- left.upperBound));
+ left.geti64ApproxUpperBound()));
} else {
currElement.setUpperBound(64);
}
break;
}
case ShrUInt64: {
- if (right.constVal.has_value()) {
- auto shifts = std::min(Index(Bits::getEffectiveShifts(
- right.constVal.value().geti64(), Type::i64)),
- left.upperBound);
+ std::optional<Literal> constRightValue = right.getLiteral();
+ if (constRightValue.has_value()) {
+ Index leftUpperBound = left.geti64ApproxUpperBound();
+ auto shifts =
+ std::min(Index(Bits::getEffectiveShifts(
+ constRightValue.value().geti64(), Type::i64)),
+ leftUpperBound);
currElement.setUpperBound(
- std::max(Index(0), left.upperBound - shifts));
+ std::max(Index(0), leftUpperBound - shifts));
} else {
currElement.setUpperBound(64);
}
break;
}
case ShrSInt64: {
- if (right.constVal.has_value()) {
- if (left.upperBound == 64) {
+ std::optional<Literal> constRightValue = right.getLiteral();
+ Index leftUpperBound = left.geti64ApproxUpperBound();
+ if (constRightValue.has_value()) {
+ if (leftUpperBound == 64) {
currElement.setUpperBound(64);
} else {
auto shifts =
std::min(Index(Bits::getEffectiveShifts(
- right.constVal.value().geti64(), Type::i64)),
- left.upperBound);
+ constRightValue.value().geti64(), Type::i64)),
+ leftUpperBound);
currElement.setUpperBound(
- std::max(Index(0), left.upperBound - shifts));
+ std::max(Index(0), leftUpperBound - shifts));
}
} else {
currElement.setUpperBound(64);
@@ -273,14 +319,14 @@
}
if (collectingResults && addInformation) {
- exprMaxBounds[curr] = currElement.upperBound;
+ exprMaxBounds[curr] = currElement.getUpperBound().value();
}
currState->push(std::move(currElement));
}
void visitUnary(Unary* curr) {
- MaxBitsLattice::Element unaryVal = currState->pop();
+ MaxBitsLattice::Element val = currState->pop();
MaxBitsLattice::Element currElement = bitsLattice.getBottom();
bool addInformation = true;
@@ -297,35 +343,43 @@
currElement.setUpperBound(7);
break;
}
- case WrapInt64:
+ case WrapInt64: {
+ currElement.setUpperBound(val.geti64ApproxUpperBound());
+ break;
+ }
case ExtendUInt32: {
- currElement.setUpperBound(unaryVal.upperBound);
+ currElement.setUpperBound(val.geti32ApproxUpperBound());
break;
}
case ExtendS8Int32: {
- currElement.setUpperBound(
- unaryVal.upperBound >= 8 ? Index(32) : unaryVal.upperBound);
+ Index upperBound = val.geti32ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 8 ? Index(32) : upperBound);
break;
}
case ExtendS16Int32: {
- currElement.setUpperBound(
- unaryVal.upperBound >= 16 ? Index(32) : unaryVal.upperBound);
+ Index upperBound = val.geti32ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 16 ? Index(32) : upperBound);
break;
}
case ExtendS8Int64: {
- currElement.setUpperBound(
- unaryVal.upperBound >= 8 ? Index(64) : unaryVal.upperBound);
+ Index upperBound = val.geti64ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 8 ? Index(64) : upperBound);
break;
}
case ExtendS16Int64: {
- currElement.setUpperBound(
- unaryVal.upperBound >= 16 ? Index(64) : unaryVal.upperBound);
+ Index upperBound = val.geti64ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 16 ? Index(64) : upperBound);
break;
}
- case ExtendS32Int64:
+ case ExtendS32Int64: {
+ Index upperBound = val.geti64ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 32 ? Index(64) : upperBound);
+ break;
+ }
+ // TODO: What's the difference of this with the above?
case ExtendSInt32: {
- currElement.setUpperBound(
- unaryVal.upperBound >= 32 ? Index(64) : unaryVal.upperBound);
+ Index upperBound = val.geti32ApproxUpperBound();
+ currElement.setUpperBound(upperBound >= 32 ? Index(64) : upperBound);
break;
}
default: {
@@ -334,7 +388,7 @@
}
if (collectingResults && addInformation) {
- exprMaxBounds[curr] = currElement.upperBound;
+ exprMaxBounds[curr] = currElement.getUpperBound().value();
}
currState->push(std::move(currElement));
@@ -343,8 +397,11 @@
void visitLocalSet(LocalSet* curr) {
MaxBitsLattice::Element val = currState->pop();
- if (collectingResults && !val.isTop()) {
- exprMaxBounds[curr] = val.upperBound;
+ if (collectingResults && curr->isTee()) {
+ std::optional<Index> upperBound = val.getUpperBound();
+ if (upperBound.has_value()) {
+ exprMaxBounds[curr] = upperBound.value();
+ }
}
}
diff --git a/src/ir/bits.h b/src/ir/bits.h
index 25d80fb..ec7a1d3 100644
--- a/src/ir/bits.h
+++ b/src/ir/bits.h
@@ -163,6 +163,9 @@
return 32;
}
int32_t bitsRight = getMaxBits(c);
+ // TODO: If the bitsRight is equal to maxBitsLeft, because we are
+ // making an estimate, it is possible that the right could be 1,
+ // meaning that the actual division result is maxBitsLeft.
return std::max(0, maxBitsLeft - bitsRight + 1);
}
return 32;
diff --git a/test/gtest/cfg.cpp b/test/gtest/cfg.cpp
index 1e85834..a5a699c 100644
--- a/test/gtest/cfg.cpp
+++ b/test/gtest/cfg.cpp
@@ -680,6 +680,7 @@
LatticeComparison::EQUAL);
}
+// TODO: Add more thorough test cases for max bits analysis.
TEST_F(CFGTest, MaxBitsAnalysis) {
auto moduleText = R"wasm(
(module
