summaryrefslogtreecommitdiff
path: root/src/tools
diff options
context:
space:
mode:
Diffstat (limited to 'src/tools')
-rw-r--r--src/tools/fuzzing/fuzzing.cpp40
-rw-r--r--src/tools/wasm-ctor-eval.cpp15
-rw-r--r--src/tools/wasm-metadce.cpp7
-rw-r--r--src/tools/wasm-reduce.cpp14
4 files changed, 36 insertions, 40 deletions
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index e5afbf559..c828c84d0 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -191,26 +191,30 @@ void TranslateToFuzzReader::setupMemory() {
// need at least one segment for memory.inits
size_t numSegments = upTo(8) + 1;
for (size_t i = 0; i < numSegments; i++) {
- Memory::Segment segment;
- segment.isPassive = bool(upTo(2));
+ auto segment = builder.makeDataSegment();
+ segment->setName(Name::fromInt(i), false);
+ segment->isPassive = bool(upTo(2));
size_t segSize = upTo(USABLE_MEMORY * 2);
- segment.data.resize(segSize);
+ segment->data.resize(segSize);
for (size_t j = 0; j < segSize; j++) {
- segment.data[j] = upTo(512);
+ segment->data[j] = upTo(512);
}
- if (!segment.isPassive) {
- segment.offset = builder.makeConst(int32_t(memCovered));
+ if (!segment->isPassive) {
+ segment->offset = builder.makeConst(int32_t(memCovered));
memCovered += segSize;
}
- wasm.memory.segments.push_back(segment);
+ wasm.dataSegments.push_back(std::move(segment));
}
} else {
// init some data
- wasm.memory.segments.emplace_back(builder.makeConst(int32_t(0)));
+ auto segment = builder.makeDataSegment();
+ segment->offset = builder.makeConst(int32_t(0));
+ segment->setName(Name::fromInt(0), false);
+ wasm.dataSegments.push_back(std::move(segment));
auto num = upTo(USABLE_MEMORY * 2);
for (size_t i = 0; i < num; i++) {
auto value = upTo(512);
- wasm.memory.segments[0].data.push_back(value >= 256 ? 0 : (value & 0xff));
+ wasm.dataSegments[0]->data.push_back(value >= 256 ? 0 : (value & 0xff));
}
}
// Add memory hasher helper (for the hash, see hash.h). The function looks
@@ -326,10 +330,10 @@ void TranslateToFuzzReader::setupTags() {
}
void TranslateToFuzzReader::finalizeMemory() {
- for (auto& segment : wasm.memory.segments) {
- Address maxOffset = segment.data.size();
- if (!segment.isPassive) {
- if (auto* offset = segment.offset->dynCast<GlobalGet>()) {
+ for (auto& segment : wasm.dataSegments) {
+ Address maxOffset = segment->data.size();
+ if (!segment->isPassive) {
+ if (auto* offset = segment->offset->dynCast<GlobalGet>()) {
// Using a non-imported global in a segment offset is not valid in
// wasm. This can occur due to us making what used to be an imported
// global, in initial contents, be not imported any more. To fix that,
@@ -342,11 +346,11 @@ void TranslateToFuzzReader::finalizeMemory() {
if (!wasm.getGlobal(offset->name)->imported()) {
// TODO: It would be better to avoid segment overlap so that
// MemoryPacking can run.
- segment.offset =
+ segment->offset =
builder.makeConst(Literal::makeFromInt32(0, Type::i32));
}
}
- if (auto* offset = segment.offset->dynCast<Const>()) {
+ if (auto* offset = segment->offset->dynCast<Const>()) {
maxOffset = maxOffset + offset->value.getInteger();
}
}
@@ -2905,8 +2909,8 @@ Expression* TranslateToFuzzReader::makeMemoryInit() {
if (!allowMemory) {
return makeTrivial(Type::none);
}
- uint32_t segment = upTo(wasm.memory.segments.size());
- size_t totalSize = wasm.memory.segments[segment].data.size();
+ uint32_t segment = upTo(wasm.dataSegments.size());
+ size_t totalSize = wasm.dataSegments[segment]->data.size();
size_t offsetVal = upTo(totalSize);
size_t sizeVal = upTo(totalSize - offsetVal);
Expression* dest = makePointer();
@@ -2919,7 +2923,7 @@ Expression* TranslateToFuzzReader::makeDataDrop() {
if (!allowMemory) {
return makeTrivial(Type::none);
}
- return builder.makeDataDrop(upTo(wasm.memory.segments.size()));
+ return builder.makeDataDrop(upTo(wasm.dataSegments.size()));
}
Expression* TranslateToFuzzReader::makeMemoryCopy() {
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp
index 59e54d4f7..22fa87633 100644
--- a/src/tools/wasm-ctor-eval.cpp
+++ b/src/tools/wasm-ctor-eval.cpp
@@ -426,18 +426,19 @@ private:
void applyMemoryToModule() {
// Memory must have already been flattened into the standard form: one
// segment at offset 0, or none.
- if (wasm->memory.segments.empty()) {
+ if (wasm->dataSegments.empty()) {
Builder builder(*wasm);
- std::vector<char> empty;
- wasm->memory.segments.push_back(
- Memory::Segment(builder.makeConst(int32_t(0)), empty));
+ auto curr = builder.makeDataSegment();
+ curr->offset = builder.makeConst(int32_t(0));
+ curr->setName(Name::fromInt(0), false);
+ wasm->dataSegments.push_back(std::move(curr));
}
- auto& segment = wasm->memory.segments[0];
- assert(segment.offset->cast<Const>()->value.getInteger() == 0);
+ auto& segment = wasm->dataSegments[0];
+ assert(segment->offset->cast<Const>()->value.getInteger() == 0);
// Copy the current memory contents after execution into the Module's
// memory.
- segment.data = memory;
+ segment->data = memory;
}
// Serializing GC data requires more work than linear memory, because
diff --git a/src/tools/wasm-metadce.cpp b/src/tools/wasm-metadce.cpp
index 4b12446f4..741afb22f 100644
--- a/src/tools/wasm-metadce.cpp
+++ b/src/tools/wasm-metadce.cpp
@@ -235,11 +235,8 @@ struct MetaDCEGraph {
});
rooter.walk(segment->offset);
});
- for (auto& segment : wasm.memory.segments) {
- if (!segment.isPassive) {
- rooter.walk(segment.offset);
- }
- }
+ ModuleUtils::iterActiveDataSegments(
+ wasm, [&](DataSegment* segment) { rooter.walk(segment->offset); });
// A parallel scanner for function bodies
struct Scanner : public WalkerPass<PostWalker<Scanner>> {
diff --git a/src/tools/wasm-reduce.cpp b/src/tools/wasm-reduce.cpp
index 3cfc0bb11..2276f66a4 100644
--- a/src/tools/wasm-reduce.cpp
+++ b/src/tools/wasm-reduce.cpp
@@ -752,20 +752,14 @@ struct Reducer
// TODO: bisection on segment shrinking?
- void visitMemory(Memory* curr) {
- std::cerr << "| try to simplify memory\n";
-
+ void visitDataSegment(DataSegment* curr) {
// try to reduce to first function. first, shrink segment elements.
// while we are shrinking successfully, keep going exponentially.
bool shrank = false;
- for (auto& segment : curr->segments) {
- shrank = shrinkByReduction(&segment, 2);
- }
+ shrank = shrinkByReduction(curr, 2);
// the "opposite" of shrinking: copy a 'zero' element
- for (auto& segment : curr->segments) {
- reduceByZeroing(
- &segment, 0, [](char item) { return item == 0; }, 2, shrank);
- }
+ reduceByZeroing(
+ curr, 0, [](char item) { return item == 0; }, 2, shrank);
}
template<typename T, typename U, typename C>
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-17 23:30:30 +0000