summaryrefslogtreecommitdiff
path: root/src/ir
diff options
context:
space:
mode:
Diffstat (limited to 'src/ir')
-rw-r--r--src/ir/ReFinalize.cpp10
-rw-r--r--src/ir/child-typer.h41
-rw-r--r--src/ir/cost.h13
-rw-r--r--src/ir/effects.h31
-rw-r--r--src/ir/possible-contents.cpp20
-rw-r--r--src/ir/subtype-exprs.h5
-rw-r--r--src/ir/type-updating.cpp9
7 files changed, 3 insertions, 126 deletions
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index c8f83f1ba..8fae5d073 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -170,18 +170,8 @@ void ReFinalize::visitStringMeasure(StringMeasure* curr) { curr->finalize(); }
void ReFinalize::visitStringEncode(StringEncode* curr) { curr->finalize(); }
void ReFinalize::visitStringConcat(StringConcat* curr) { curr->finalize(); }
void ReFinalize::visitStringEq(StringEq* curr) { curr->finalize(); }
-void ReFinalize::visitStringAs(StringAs* curr) { curr->finalize(); }
-void ReFinalize::visitStringWTF8Advance(StringWTF8Advance* curr) {
- curr->finalize();
-}
void ReFinalize::visitStringWTF16Get(StringWTF16Get* curr) { curr->finalize(); }
-void ReFinalize::visitStringIterNext(StringIterNext* curr) { curr->finalize(); }
-void ReFinalize::visitStringIterMove(StringIterMove* curr) { curr->finalize(); }
void ReFinalize::visitStringSliceWTF(StringSliceWTF* curr) { curr->finalize(); }
-void ReFinalize::visitStringSliceIter(StringSliceIter* curr) {
- curr->finalize();
-}
-
void ReFinalize::visitContNew(ContNew* curr) { curr->finalize(); }
void ReFinalize::visitContBind(ContBind* curr) { curr->finalize(); }
void ReFinalize::visitResume(Resume* curr) { curr->finalize(); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
index 94ef11d77..e015f3db8 100644
--- a/src/ir/child-typer.h
+++ b/src/ir/child-typer.h
@@ -991,11 +991,7 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
void visitStringConst(StringConst* curr) {}
void visitStringMeasure(StringMeasure* curr) {
- if (curr->op == StringMeasureWTF16View) {
- note(&curr->ref, Type(HeapType::stringview_wtf16, Nullable));
- } else {
- note(&curr->ref, Type(HeapType::string, Nullable));
- }
+ note(&curr->ref, Type(HeapType::string, Nullable));
}
void visitStringEncode(StringEncode* curr,
@@ -1035,48 +1031,17 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
note(&curr->right, stringref);
}
- void visitStringAs(StringAs* curr) {
- note(&curr->ref, Type(HeapType::string, Nullable));
- }
-
- void visitStringWTF8Advance(StringWTF8Advance* curr) {
- note(&curr->ref, Type(HeapType::stringview_wtf8, Nullable));
- note(&curr->pos, Type::i32);
- note(&curr->bytes, Type::i32);
- }
-
void visitStringWTF16Get(StringWTF16Get* curr) {
- note(&curr->ref, Type(HeapType::stringview_wtf16, Nullable));
+ note(&curr->ref, Type(HeapType::string, Nullable));
note(&curr->pos, Type::i32);
}
- void visitStringIterNext(StringIterNext* curr) {
- note(&curr->ref, Type(HeapType::stringview_iter, Nullable));
- }
-
- void visitStringIterMove(StringIterMove* curr) {
- note(&curr->ref, Type(HeapType::stringview_iter, Nullable));
- note(&curr->num, Type::i32);
- }
-
void visitStringSliceWTF(StringSliceWTF* curr) {
- switch (curr->op) {
- case StringSliceWTF8:
- note(&curr->ref, Type(HeapType::stringview_wtf8, Nullable));
- break;
- case StringSliceWTF16:
- note(&curr->ref, Type(HeapType::stringview_wtf16, Nullable));
- break;
- }
+ note(&curr->ref, Type(HeapType::string, Nullable));
note(&curr->start, Type::i32);
note(&curr->end, Type::i32);
}
- void visitStringSliceIter(StringSliceIter* curr) {
- note(&curr->ref, Type(HeapType::stringview_iter, Nullable));
- note(&curr->num, Type::i32);
- }
-
void visitContBind(ContBind* curr) {
auto paramsBefore =
curr->contTypeBefore.getContinuation().type.getSignature().params;
diff --git a/src/ir/cost.h b/src/ir/cost.h
index edb39546d..8af68dbf1 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -706,25 +706,12 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
// "3" is chosen since strings might or might not be interned in the engine.
return 3 + visit(curr->left) + visit(curr->right);
}
- CostType visitStringAs(StringAs* curr) { return 4 + visit(curr->ref); }
- CostType visitStringWTF8Advance(StringWTF8Advance* curr) {
- return 4 + visit(curr->ref) + visit(curr->pos) + visit(curr->bytes);
- }
CostType visitStringWTF16Get(StringWTF16Get* curr) {
return 1 + visit(curr->ref) + visit(curr->pos);
}
- CostType visitStringIterNext(StringIterNext* curr) {
- return 2 + visit(curr->ref);
- }
- CostType visitStringIterMove(StringIterMove* curr) {
- return 4 + visit(curr->ref) + visit(curr->num);
- }
CostType visitStringSliceWTF(StringSliceWTF* curr) {
return 8 + visit(curr->ref) + visit(curr->start) + visit(curr->end);
}
- CostType visitStringSliceIter(StringSliceIter* curr) {
- return 8 + visit(curr->ref) + visit(curr->num);
- }
CostType visitContBind(ContBind* curr) {
// Inspired by struct.new: The only cost of cont.bind is that it may need to
diff --git a/src/ir/effects.h b/src/ir/effects.h
index b1b4c7053..87b77601f 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -997,45 +997,14 @@ private:
}
}
}
- void visitStringAs(StringAs* curr) {
- // traps when ref is null.
- parent.implicitTrap = true;
- }
- void visitStringWTF8Advance(StringWTF8Advance* curr) {
- // traps when ref is null.
- parent.implicitTrap = true;
- }
void visitStringWTF16Get(StringWTF16Get* curr) {
// traps when ref is null.
parent.implicitTrap = true;
}
- void visitStringIterNext(StringIterNext* curr) {
- // traps when ref is null.
- parent.implicitTrap = true;
- // modifies state in the iterator. we model that as accessing heap memory
- // in an array atm TODO consider adding a new effect type for this (we
- // added one for arrays because struct/array operations often interleave,
- // say with vtable accesses, but it's not clear adding overhead to this
- // class is worth it for string iters)
- parent.readsArray = true;
- parent.writesArray = true;
- }
- void visitStringIterMove(StringIterMove* curr) {
- // traps when ref is null.
- parent.implicitTrap = true;
- // see StringIterNext.
- parent.readsArray = true;
- parent.writesArray = true;
- }
void visitStringSliceWTF(StringSliceWTF* curr) {
// traps when ref is null.
parent.implicitTrap = true;
}
- void visitStringSliceIter(StringSliceIter* curr) {
- // traps when ref is null.
- parent.implicitTrap = true;
- }
-
void visitContBind(ContBind* curr) {
// traps when curr->cont is null ref.
parent.implicitTrap = true;
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index c44cd7ce1..ac320c419 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -1084,34 +1084,14 @@ struct InfoCollector
// TODO: optimize when possible
addRoot(curr);
}
- void visitStringAs(StringAs* curr) {
- // TODO: optimize when possible
- addRoot(curr);
- }
- void visitStringWTF8Advance(StringWTF8Advance* curr) {
- // TODO: optimize when possible
- addRoot(curr);
- }
void visitStringWTF16Get(StringWTF16Get* curr) {
// TODO: optimize when possible
addRoot(curr);
}
- void visitStringIterNext(StringIterNext* curr) {
- // TODO: optimize when possible
- addRoot(curr);
- }
- void visitStringIterMove(StringIterMove* curr) {
- // TODO: optimize when possible
- addRoot(curr);
- }
void visitStringSliceWTF(StringSliceWTF* curr) {
// TODO: optimize when possible
addRoot(curr);
}
- void visitStringSliceIter(StringSliceIter* curr) {
- // TODO: optimize when possible
- addRoot(curr);
- }
// TODO: Model which throws can go to which catches. For now, anything thrown
// is sent to the location of that tag, and any catch of that tag can
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
index 1457e1ef5..f563cce14 100644
--- a/src/ir/subtype-exprs.h
+++ b/src/ir/subtype-exprs.h
@@ -383,13 +383,8 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
void visitStringEncode(StringEncode* curr) {}
void visitStringConcat(StringConcat* curr) {}
void visitStringEq(StringEq* curr) {}
- void visitStringAs(StringAs* curr) {}
- void visitStringWTF8Advance(StringWTF8Advance* curr) {}
void visitStringWTF16Get(StringWTF16Get* curr) {}
- void visitStringIterNext(StringIterNext* curr) {}
- void visitStringIterMove(StringIterMove* curr) {}
void visitStringSliceWTF(StringSliceWTF* curr) {}
- void visitStringSliceIter(StringSliceIter* curr) {}
void visitContBind(ContBind* curr) { WASM_UNREACHABLE("not implemented"); }
void visitContNew(ContNew* curr) { WASM_UNREACHABLE("not implemented"); }
diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp
index 0144b9330..12a8c7c36 100644
--- a/src/ir/type-updating.cpp
+++ b/src/ir/type-updating.cpp
@@ -304,15 +304,6 @@ namespace TypeUpdating {
bool canHandleAsLocal(Type type) {
// TODO: Inline this into its callers.
- if (type.isRef()) {
- // V8 does not accept nullable string views, and so we must avoid putting
- // them in locals (as even a non-nullable one may end up nullable if we see
- // situations that require fixing in handleNonDefaultableLocals).
- auto heapType = type.getHeapType();
- return heapType != HeapType::stringview_wtf8 &&
- heapType != HeapType::stringview_wtf16 &&
- heapType != HeapType::stringview_iter;
- }
return type.isConcrete();
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-08-27 15:48:54 +0000