diff options
Diffstat (limited to 'src/passes')
39 files changed, 461 insertions, 461 deletions
diff --git a/src/passes/AlignmentLowering.cpp b/src/passes/AlignmentLowering.cpp index fc03a8b74..05ec2892f 100644 --- a/src/passes/AlignmentLowering.cpp +++ b/src/passes/AlignmentLowering.cpp @@ -43,13 +43,13 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { ret = builder.makeBinary( OrInt32, builder.makeLoad( - 1, false, curr->offset, 1, builder.makeGetLocal(temp, i32), i32), + 1, false, curr->offset, 1, builder.makeLocalGet(temp, i32), i32), builder.makeBinary(ShlInt32, builder.makeLoad(1, false, curr->offset + 1, 1, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), i32), builder.makeConst(Literal(int32_t(8))))); if (curr->signed_) { @@ -62,13 +62,13 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { builder.makeBinary( OrInt32, builder.makeLoad( - 1, false, curr->offset, 1, builder.makeGetLocal(temp, i32), i32), + 1, false, curr->offset, 1, builder.makeLocalGet(temp, i32), i32), builder.makeBinary(ShlInt32, builder.makeLoad(1, false, curr->offset + 1, 1, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), i32), builder.makeConst(Literal(int32_t(8))))), builder.makeBinary( @@ -78,7 +78,7 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { false, curr->offset + 2, 1, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), i32), builder.makeConst(Literal(int32_t(16)))), builder.makeBinary(ShlInt32, @@ -86,20 +86,20 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { false, curr->offset + 3, 1, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), i32), builder.makeConst(Literal(int32_t(24)))))); } else if (curr->align == 2) { ret = builder.makeBinary( OrInt32, builder.makeLoad( - 2, false, curr->offset, 2, builder.makeGetLocal(temp, i32), i32), + 2, false, curr->offset, 2, builder.makeLocalGet(temp, i32), i32), builder.makeBinary(ShlInt32, builder.makeLoad(2, false, curr->offset + 2, 2, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), i32), builder.makeConst(Literal(int32_t(16))))); } else { @@ -109,7 +109,7 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { WASM_UNREACHABLE(); } replaceCurrent( - builder.makeBlock({builder.makeSetLocal(temp, curr->ptr), ret})); + builder.makeBlock({builder.makeLocalSet(temp, curr->ptr), ret})); } void visitStore(Store* curr) { @@ -126,23 +126,23 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { auto tempPtr = builder.addVar(getFunction(), i32); auto tempValue = builder.addVar(getFunction(), i32); auto* block = - builder.makeBlock({builder.makeSetLocal(tempPtr, curr->ptr), - builder.makeSetLocal(tempValue, curr->value)}); + builder.makeBlock({builder.makeLocalSet(tempPtr, curr->ptr), + builder.makeLocalSet(tempValue, curr->value)}); if (curr->bytes == 2) { block->list.push_back( builder.makeStore(1, curr->offset, 1, - builder.makeGetLocal(tempPtr, i32), - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempPtr, i32), + builder.makeLocalGet(tempValue, i32), i32)); block->list.push_back(builder.makeStore( 1, curr->offset + 1, 1, - builder.makeGetLocal(tempPtr, i32), + builder.makeLocalGet(tempPtr, i32), builder.makeBinary(ShrUInt32, - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempValue, i32), builder.makeConst(Literal(int32_t(8)))), i32)); } else if (curr->bytes == 4) { @@ -151,34 +151,34 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { builder.makeStore(1, curr->offset, 1, - builder.makeGetLocal(tempPtr, i32), - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempPtr, i32), + builder.makeLocalGet(tempValue, i32), i32)); block->list.push_back(builder.makeStore( 1, curr->offset + 1, 1, - builder.makeGetLocal(tempPtr, i32), + builder.makeLocalGet(tempPtr, i32), builder.makeBinary(ShrUInt32, - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempValue, i32), builder.makeConst(Literal(int32_t(8)))), i32)); block->list.push_back(builder.makeStore( 1, curr->offset + 2, 1, - builder.makeGetLocal(tempPtr, i32), + builder.makeLocalGet(tempPtr, i32), builder.makeBinary(ShrUInt32, - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempValue, i32), builder.makeConst(Literal(int32_t(16)))), i32)); block->list.push_back(builder.makeStore( 1, curr->offset + 3, 1, - builder.makeGetLocal(tempPtr, i32), + builder.makeLocalGet(tempPtr, i32), builder.makeBinary(ShrUInt32, - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempValue, i32), builder.makeConst(Literal(int32_t(24)))), i32)); } else if (curr->align == 2) { @@ -186,16 +186,16 @@ struct AlignmentLowering : public WalkerPass<PostWalker<AlignmentLowering>> { builder.makeStore(2, curr->offset, 2, - builder.makeGetLocal(tempPtr, i32), - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempPtr, i32), + builder.makeLocalGet(tempValue, i32), i32)); block->list.push_back(builder.makeStore( 2, curr->offset + 2, 2, - builder.makeGetLocal(tempPtr, i32), + builder.makeLocalGet(tempPtr, i32), builder.makeBinary(ShrUInt32, - builder.makeGetLocal(tempValue, i32), + builder.makeLocalGet(tempValue, i32), builder.makeConst(Literal(int32_t(16)))), i32)); } else { diff --git a/src/passes/AvoidReinterprets.cpp b/src/passes/AvoidReinterprets.cpp index d9b93b188..5aa1d338b 100644 --- a/src/passes/AvoidReinterprets.cpp +++ b/src/passes/AvoidReinterprets.cpp @@ -35,8 +35,8 @@ static bool canReplaceWithReinterpret(Load* load) { return load->type != unreachable && load->bytes == getTypeSize(load->type); } -static Load* getSingleLoad(LocalGraph* localGraph, GetLocal* get) { - std::set<GetLocal*> seen; +static Load* getSingleLoad(LocalGraph* localGraph, LocalGet* get) { + std::set<LocalGet*> seen; seen.insert(get); while (1) { auto& sets = localGraph->getSetses[get]; @@ -48,7 +48,7 @@ static Load* getSingleLoad(LocalGraph* localGraph, GetLocal* get) { return nullptr; } auto* value = Properties::getFallthrough(set->value); - if (auto* parentGet = value->dynCast<GetLocal>()) { + if (auto* parentGet = value->dynCast<LocalGet>()) { if (seen.count(parentGet)) { // We are in a cycle of gets, in unreachable code. return nullptr; @@ -98,7 +98,7 @@ struct AvoidReinterprets : public WalkerPass<PostWalker<AvoidReinterprets>> { void visitUnary(Unary* curr) { if (isReinterpret(curr)) { if (auto* get = - Properties::getFallthrough(curr->value)->dynCast<GetLocal>()) { + Properties::getFallthrough(curr->value)->dynCast<LocalGet>()) { if (auto* load = getSingleLoad(localGraph, get)) { auto& info = infos[load]; info.reinterpreted = true; @@ -143,14 +143,14 @@ struct AvoidReinterprets : public WalkerPass<PostWalker<AvoidReinterprets>> { if (canReplaceWithReinterpret(load)) { replaceCurrent(makeReinterpretedLoad(load, load->ptr)); } - } else if (auto* get = value->dynCast<GetLocal>()) { + } else if (auto* get = value->dynCast<LocalGet>()) { if (auto* load = getSingleLoad(localGraph, get)) { auto iter = infos.find(load); if (iter != infos.end()) { auto& info = iter->second; // A reinterpret of a get of a load - use the new local. Builder builder(*module); - replaceCurrent(builder.makeGetLocal( + replaceCurrent(builder.makeLocalGet( info.reinterpretedLocal, reinterpretType(load->type))); } } @@ -164,16 +164,16 @@ struct AvoidReinterprets : public WalkerPass<PostWalker<AvoidReinterprets>> { auto& info = iter->second; Builder builder(*module); auto* ptr = curr->ptr; - curr->ptr = builder.makeGetLocal(info.ptrLocal, i32); + curr->ptr = builder.makeLocalGet(info.ptrLocal, i32); // Note that the other load can have its sign set to false - if the // original were an integer, the other is a float anyhow; and if // original were a float, we don't know what sign to use. replaceCurrent(builder.makeBlock( - {builder.makeSetLocal(info.ptrLocal, ptr), - builder.makeSetLocal( + {builder.makeLocalSet(info.ptrLocal, ptr), + builder.makeLocalSet( info.reinterpretedLocal, makeReinterpretedLoad(curr, - builder.makeGetLocal(info.ptrLocal, i32))), + builder.makeLocalGet(info.ptrLocal, i32))), curr})); } } diff --git a/src/passes/CoalesceLocals.cpp b/src/passes/CoalesceLocals.cpp index af13419d3..9bc635f80 100644 --- a/src/passes/CoalesceLocals.cpp +++ b/src/passes/CoalesceLocals.cpp @@ -51,7 +51,7 @@ struct CoalesceLocals void calculateInterferences(); - void calculateInterferences(const LocalSet& locals); + void calculateInterferences(const SetOfLocals& locals); void pickIndicesFromOrder(std::vector<Index>& order, std::vector<Index>& indices); @@ -120,7 +120,7 @@ void CoalesceLocals::increaseBackEdgePriorities() { } for (auto& action : arrivingBlock->contents.actions) { if (action.isSet()) { - auto* set = (*action.origin)->cast<SetLocal>(); + auto* set = (*action.origin)->cast<LocalSet>(); if (auto* get = getCopy(set)) { // this is indeed a copy, add to the cost (default cost is 2, so // this adds 50%, and can mostly break ties) @@ -163,7 +163,7 @@ void CoalesceLocals::calculateInterferences() { } // Params have a value on entry, so mark them as live, as variables // live at the entry expect their zero-init value. - LocalSet start = entry->contents.start; + SetOfLocals start = entry->contents.start; auto numParams = getFunction()->getNumParams(); for (Index i = 0; i < numParams; i++) { start.insert(i); @@ -171,7 +171,7 @@ void CoalesceLocals::calculateInterferences() { calculateInterferences(start); } -void CoalesceLocals::calculateInterferences(const LocalSet& locals) { +void CoalesceLocals::calculateInterferences(const SetOfLocals& locals) { Index size = locals.size(); for (Index i = 0; i < size; i++) { for (Index j = i + 1; j < size; j++) { @@ -358,15 +358,15 @@ void CoalesceLocals::applyIndices(std::vector<Index>& indices, auto& actions = curr->contents.actions; for (auto& action : actions) { if (action.isGet()) { - auto* get = (*action.origin)->cast<GetLocal>(); + auto* get = (*action.origin)->cast<LocalGet>(); get->index = indices[get->index]; } else if (action.isSet()) { - auto* set = (*action.origin)->cast<SetLocal>(); + auto* set = (*action.origin)->cast<LocalSet>(); set->index = indices[set->index]; // in addition, we can optimize out redundant copies and ineffective // sets - GetLocal* get; - if ((get = set->value->dynCast<GetLocal>()) && + LocalGet* get; + if ((get = set->value->dynCast<LocalGet>()) && get->index == set->index) { action.removeCopy(); continue; @@ -378,7 +378,7 @@ void CoalesceLocals::applyIndices(std::vector<Index>& indices, *action.origin = set->value; if (!set->isTee()) { // we need to drop it - Drop* drop = ExpressionManipulator::convert<SetLocal, Drop>(set); + Drop* drop = ExpressionManipulator::convert<LocalSet, Drop>(set); drop->value = *action.origin; *action.origin = drop; } diff --git a/src/passes/CodePushing.cpp b/src/passes/CodePushing.cpp index 88e363541..4eb69b92e 100644 --- a/src/passes/CodePushing.cpp +++ b/src/passes/CodePushing.cpp @@ -60,14 +60,14 @@ struct LocalAnalyzer : public PostWalker<LocalAnalyzer> { Index getNumGets(Index i) { return numGets[i]; } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { if (numSets[curr->index] == 0) { sfa[curr->index] = false; } numGets[curr->index]++; } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { numSets[curr->index]++; if (numSets[curr->index] > 1) { sfa[curr->index] = false; @@ -116,8 +116,8 @@ public: } private: - SetLocal* isPushable(Expression* curr) { - auto* set = curr->dynCast<SetLocal>(); + LocalSet* isPushable(Expression* curr) { + auto* set = curr->dynCast<LocalSet>(); if (!set) { return nullptr; } @@ -162,7 +162,7 @@ private: // it is ok to ignore the branching here, that is the crucial point of this // opt cumulativeEffects.branches = false; - std::vector<SetLocal*> toPush; + std::vector<LocalSet*> toPush; Index i = pushPoint - 1; while (1) { auto* pushable = isPushable(list[i]); @@ -223,7 +223,7 @@ private: } // Pushables may need to be scanned more than once, so cache their effects. - std::unordered_map<SetLocal*, EffectAnalyzer> pushableEffects; + std::unordered_map<LocalSet*, EffectAnalyzer> pushableEffects; }; struct CodePushing : public WalkerPass<PostWalker<CodePushing>> { @@ -246,7 +246,7 @@ struct CodePushing : public WalkerPass<PostWalker<CodePushing>> { walk(func->body); } - void visitGetLocal(GetLocal* curr) { numGetsSoFar[curr->index]++; } + void visitLocalGet(LocalGet* curr) { numGetsSoFar[curr->index]++; } void visitBlock(Block* curr) { // Pushing code only makes sense if we are size 3 or above: we need diff --git a/src/passes/ConstHoisting.cpp b/src/passes/ConstHoisting.cpp index 37799e8b8..149ba6504 100644 --- a/src/passes/ConstHoisting.cpp +++ b/src/passes/ConstHoisting.cpp @@ -127,9 +127,9 @@ private: auto type = (*(vec[0]))->type; Builder builder(*getModule()); auto temp = builder.addVar(getFunction(), type); - auto* ret = builder.makeSetLocal(temp, *(vec[0])); + auto* ret = builder.makeLocalSet(temp, *(vec[0])); for (auto item : vec) { - *item = builder.makeGetLocal(temp, type); + *item = builder.makeLocalGet(temp, type); } return ret; } diff --git a/src/passes/DeadArgumentElimination.cpp b/src/passes/DeadArgumentElimination.cpp index ab2e8e5e3..9d60efd42 100644 --- a/src/passes/DeadArgumentElimination.cpp +++ b/src/passes/DeadArgumentElimination.cpp @@ -93,7 +93,7 @@ struct DAEScanner // cfg traversal work - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { if (currBasicBlock) { auto& localUses = currBasicBlock->contents.localUses; auto index = curr->index; @@ -103,7 +103,7 @@ struct DAEScanner } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (currBasicBlock) { auto& localUses = currBasicBlock->contents.localUses; auto index = curr->index; @@ -294,7 +294,7 @@ struct DAE : public Pass { // makes the parameter value unused, which lets us remove it later. Builder builder(*module); func->body = builder.makeSequence( - builder.makeSetLocal(i, builder.makeConst(value)), func->body); + builder.makeLocalSet(i, builder.makeConst(value)), func->body); // Mark it as unused, which we know it now is (no point to // re-scan just for that). infoMap[name].unusedParams.insert(i); @@ -402,8 +402,8 @@ private: : removedIndex(removedIndex), newIndex(newIndex) { walk(func->body); } - void visitGetLocal(GetLocal* curr) { updateIndex(curr->index); } - void visitSetLocal(SetLocal* curr) { updateIndex(curr->index); } + void visitLocalGet(LocalGet* curr) { updateIndex(curr->index); } + void visitLocalSet(LocalSet* curr) { updateIndex(curr->index); } void updateIndex(Index& index) { if (index == removedIndex) { index = newIndex; diff --git a/src/passes/DeadCodeElimination.cpp b/src/passes/DeadCodeElimination.cpp index c77edf357..da22a7f28 100644 --- a/src/passes/DeadCodeElimination.cpp +++ b/src/passes/DeadCodeElimination.cpp @@ -252,14 +252,14 @@ struct DeadCodeElimination DELEGATE(Call); case Expression::Id::CallIndirectId: DELEGATE(CallIndirect); - case Expression::Id::GetLocalId: - DELEGATE(GetLocal); - case Expression::Id::SetLocalId: - DELEGATE(SetLocal); - case Expression::Id::GetGlobalId: - DELEGATE(GetGlobal); - case Expression::Id::SetGlobalId: - DELEGATE(SetGlobal); + case Expression::Id::LocalGetId: + DELEGATE(LocalGet); + case Expression::Id::LocalSetId: + DELEGATE(LocalSet); + case Expression::Id::GlobalGetId: + DELEGATE(GlobalGet); + case Expression::Id::GlobalSetId: + DELEGATE(GlobalSet); case Expression::Id::LoadId: DELEGATE(Load); case Expression::Id::StoreId: @@ -400,11 +400,11 @@ struct DeadCodeElimination } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { blockifyReachableOperands({curr->value}, curr->type); } - void visitSetGlobal(SetGlobal* curr) { + void visitGlobalSet(GlobalSet* curr) { blockifyReachableOperands({curr->value}, curr->type); } diff --git a/src/passes/Flatten.cpp b/src/passes/Flatten.cpp index 55f3df6ab..9caf6cae8 100644 --- a/src/passes/Flatten.cpp +++ b/src/passes/Flatten.cpp @@ -95,11 +95,11 @@ struct Flatten } auto*& last = block->list.back(); if (isConcreteType(last->type)) { - last = builder.makeSetLocal(temp, last); + last = builder.makeLocalSet(temp, last); } block->finalize(none); // and we leave just a get of the value - auto* rep = builder.makeGetLocal(temp, type); + auto* rep = builder.makeLocalGet(temp, type); replaceCurrent(rep); // the whole block is now a prelude ourPreludes.push_back(block); @@ -117,15 +117,15 @@ struct Flatten if (isConcreteType(type)) { Index temp = builder.addVar(getFunction(), type); if (isConcreteType(iff->ifTrue->type)) { - iff->ifTrue = builder.makeSetLocal(temp, iff->ifTrue); + iff->ifTrue = builder.makeLocalSet(temp, iff->ifTrue); } if (iff->ifFalse && isConcreteType(iff->ifFalse->type)) { - iff->ifFalse = builder.makeSetLocal(temp, iff->ifFalse); + iff->ifFalse = builder.makeLocalSet(temp, iff->ifFalse); } // the whole if (+any preludes from the condition) is now a prelude prelude = rep; // and we leave just a get of the value - rep = builder.makeGetLocal(temp, type); + rep = builder.makeLocalGet(temp, type); } iff->ifTrue = getPreludesWithExpression(originalIfTrue, iff->ifTrue); if (iff->ifFalse) { @@ -145,9 +145,9 @@ struct Flatten auto type = loop->type; if (isConcreteType(type)) { Index temp = builder.addVar(getFunction(), type); - loop->body = builder.makeSetLocal(temp, loop->body); + loop->body = builder.makeLocalSet(temp, loop->body); // and we leave just a get of the value - rep = builder.makeGetLocal(temp, type); + rep = builder.makeLocalGet(temp, type); // the whole if is now a prelude ourPreludes.push_back(loop); loop->type = none; @@ -165,7 +165,7 @@ struct Flatten ourPreludes.swap(iter->second); } // special handling - if (auto* set = curr->dynCast<SetLocal>()) { + if (auto* set = curr->dynCast<LocalSet>()) { if (set->isTee()) { // we disallow local.tee if (set->value->type == unreachable) { @@ -174,7 +174,7 @@ struct Flatten // use a set in a prelude + a get set->setTee(false); ourPreludes.push_back(set); - replaceCurrent(builder.makeGetLocal(set->index, set->value->type)); + replaceCurrent(builder.makeLocalGet(set->index, set->value->type)); } } } else if (auto* br = curr->dynCast<Break>()) { @@ -183,12 +183,12 @@ struct Flatten if (isConcreteType(type)) { // we are sending a value. use a local instead Index temp = getTempForBreakTarget(br->name, type); - ourPreludes.push_back(builder.makeSetLocal(temp, br->value)); + ourPreludes.push_back(builder.makeLocalSet(temp, br->value)); if (br->condition) { // the value must also flow out ourPreludes.push_back(br); if (isConcreteType(br->type)) { - replaceCurrent(builder.makeGetLocal(temp, type)); + replaceCurrent(builder.makeLocalGet(temp, type)); } else { assert(br->type == unreachable); replaceCurrent(builder.makeUnreachable()); @@ -208,13 +208,13 @@ struct Flatten if (isConcreteType(type)) { // we are sending a value. use a local instead Index temp = builder.addVar(getFunction(), type); - ourPreludes.push_back(builder.makeSetLocal(temp, sw->value)); + ourPreludes.push_back(builder.makeLocalSet(temp, sw->value)); // we don't know which break target will be hit - assign to them all auto names = BranchUtils::getUniqueTargets(sw); for (auto name : names) { ourPreludes.push_back( - builder.makeSetLocal(getTempForBreakTarget(name, type), - builder.makeGetLocal(temp, type))); + builder.makeLocalSet(getTempForBreakTarget(name, type), + builder.makeLocalGet(temp, type))); } sw->value = nullptr; sw->finalize(); @@ -244,8 +244,8 @@ struct Flatten // use a local auto type = curr->type; Index temp = builder.addVar(getFunction(), type); - ourPreludes.push_back(builder.makeSetLocal(temp, curr)); - replaceCurrent(builder.makeGetLocal(temp, type)); + ourPreludes.push_back(builder.makeLocalSet(temp, curr)); + replaceCurrent(builder.makeLocalGet(temp, type)); } } // next, finish up: migrate our preludes if we can diff --git a/src/passes/FuncCastEmulation.cpp b/src/passes/FuncCastEmulation.cpp index ce5332a49..69bc39585 100644 --- a/src/passes/FuncCastEmulation.cpp +++ b/src/passes/FuncCastEmulation.cpp @@ -210,7 +210,7 @@ private: std::vector<Expression*> callOperands; for (Index i = 0; i < params.size(); i++) { callOperands.push_back( - fromABI(builder.makeGetLocal(i, i64), params[i], module)); + fromABI(builder.makeLocalGet(i, i64), params[i], module)); } auto* call = builder.makeCall(name, callOperands, type); std::vector<Type> thunkParams; diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp index e61e4055e..e893b6296 100644 --- a/src/passes/I64ToI32Lowering.cpp +++ b/src/passes/I64ToI32Lowering.cpp @@ -127,8 +127,8 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { c->value = Literal(uint32_t(value)); c->type = i32; high->init = builder->makeConst(Literal(uint32_t(value >> 32))); - } else if (auto* get = curr->init->dynCast<GetGlobal>()) { - high->init = builder->makeGetGlobal(makeHighName(get->name), i32); + } else if (auto* get = curr->init->dynCast<GlobalGet>()) { + high->init = builder->makeGlobalGet(makeHighName(get->name), i32); } else { WASM_UNREACHABLE(); } @@ -213,10 +213,10 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { if (hasOutParam(func->body)) { TempVar highBits = fetchOutParam(func->body); TempVar lowBits = getTemp(); - SetLocal* setLow = builder->makeSetLocal(lowBits, func->body); - SetGlobal* setHigh = builder->makeSetGlobal( - INT64_TO_32_HIGH_BITS, builder->makeGetLocal(highBits, i32)); - GetLocal* getLow = builder->makeGetLocal(lowBits, i32); + LocalSet* setLow = builder->makeLocalSet(lowBits, func->body); + GlobalSet* setHigh = builder->makeGlobalSet( + INT64_TO_32_HIGH_BITS, builder->makeLocalGet(highBits, i32)); + LocalGet* getLow = builder->makeLocalGet(lowBits, i32); func->body = builder->blockify(setLow, setHigh, getLow); } } @@ -240,7 +240,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { args.push_back(e); if (hasOutParam(e)) { TempVar argHighBits = fetchOutParam(e); - args.push_back(builder->makeGetLocal(argHighBits, i32)); + args.push_back(builder->makeLocalGet(argHighBits, i32)); fixed = true; } } @@ -252,10 +252,10 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar lowBits = getTemp(); TempVar highBits = getTemp(); auto* call = callBuilder(args, i32); - SetLocal* doCall = builder->makeSetLocal(lowBits, call); - SetLocal* setHigh = builder->makeSetLocal( - highBits, builder->makeGetGlobal(INT64_TO_32_HIGH_BITS, i32)); - GetLocal* getLow = builder->makeGetLocal(lowBits, i32); + LocalSet* doCall = builder->makeLocalSet(lowBits, call); + LocalSet* setHigh = builder->makeLocalSet( + highBits, builder->makeGlobalGet(INT64_TO_32_HIGH_BITS, i32)); + LocalGet* getLow = builder->makeLocalGet(lowBits, i32); Block* result = builder->blockify(doCall, setHigh, getLow); setOutParam(result, std::move(highBits)); replaceCurrent(result); @@ -282,7 +282,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { }); } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { const auto mappedIndex = indexMap[curr->index]; // Need to remap the local into the new naming scheme, regardless of // the type of the local. @@ -292,27 +292,27 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } curr->type = i32; TempVar highBits = getTemp(); - SetLocal* setHighBits = builder->makeSetLocal( - highBits, builder->makeGetLocal(mappedIndex + 1, i32)); + LocalSet* setHighBits = builder->makeLocalSet( + highBits, builder->makeLocalGet(mappedIndex + 1, i32)); Block* result = builder->blockify(setHighBits, curr); replaceCurrent(result); setOutParam(result, std::move(highBits)); } - void lowerTee(SetLocal* curr) { + void lowerTee(LocalSet* curr) { TempVar highBits = fetchOutParam(curr->value); TempVar tmp = getTemp(); curr->type = i32; - SetLocal* setLow = builder->makeSetLocal(tmp, curr); - SetLocal* setHigh = builder->makeSetLocal( - curr->index + 1, builder->makeGetLocal(highBits, i32)); - GetLocal* getLow = builder->makeGetLocal(tmp, i32); + LocalSet* setLow = builder->makeLocalSet(tmp, curr); + LocalSet* setHigh = builder->makeLocalSet( + curr->index + 1, builder->makeLocalGet(highBits, i32)); + LocalGet* getLow = builder->makeLocalGet(tmp, i32); Block* result = builder->blockify(setLow, setHigh, getLow); replaceCurrent(result); setOutParam(result, std::move(highBits)); } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { const auto mappedIndex = indexMap[curr->index]; // Need to remap the local into the new naming scheme, regardless of // the type of the local. Note that lowerTee depends on this happening. @@ -325,13 +325,13 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { return; } TempVar highBits = fetchOutParam(curr->value); - auto* setHigh = builder->makeSetLocal(mappedIndex + 1, - builder->makeGetLocal(highBits, i32)); + auto* setHigh = builder->makeLocalSet(mappedIndex + 1, + builder->makeLocalGet(highBits, i32)); Block* result = builder->blockify(curr, setHigh); replaceCurrent(result); } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { if (!getFunction()) { return; // if in a global init, skip - we already handled that. } @@ -340,14 +340,14 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } curr->type = i32; TempVar highBits = getTemp(); - SetLocal* setHighBits = builder->makeSetLocal( - highBits, builder->makeGetGlobal(makeHighName(curr->name), i32)); + LocalSet* setHighBits = builder->makeLocalSet( + highBits, builder->makeGlobalGet(makeHighName(curr->name), i32)); Block* result = builder->blockify(setHighBits, curr); replaceCurrent(result); setOutParam(result, std::move(highBits)); } - void visitSetGlobal(SetGlobal* curr) { + void visitGlobalSet(GlobalSet* curr) { if (!originallyI64Globals.count(curr->name)) { return; } @@ -355,8 +355,8 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { return; } TempVar highBits = fetchOutParam(curr->value); - auto* setHigh = builder->makeSetGlobal( - makeHighName(curr->name), builder->makeGetLocal(highBits, i32)); + auto* setHigh = builder->makeGlobalSet( + makeHighName(curr->name), builder->makeLocalGet(highBits, i32)); replaceCurrent(builder->makeSequence(curr, setHigh)); } @@ -368,35 +368,35 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar lowBits = getTemp(); TempVar highBits = getTemp(); TempVar ptrTemp = getTemp(); - SetLocal* setPtr = builder->makeSetLocal(ptrTemp, curr->ptr); - SetLocal* loadHigh; + LocalSet* setPtr = builder->makeLocalSet(ptrTemp, curr->ptr); + LocalSet* loadHigh; if (curr->bytes == 8) { - loadHigh = builder->makeSetLocal( + loadHigh = builder->makeLocalSet( highBits, builder->makeLoad(4, curr->signed_, curr->offset + 4, std::min(uint32_t(curr->align), uint32_t(4)), - builder->makeGetLocal(ptrTemp, i32), + builder->makeLocalGet(ptrTemp, i32), i32)); } else if (curr->signed_) { - loadHigh = builder->makeSetLocal( + loadHigh = builder->makeLocalSet( highBits, builder->makeBinary(ShrSInt32, - builder->makeGetLocal(lowBits, i32), + builder->makeLocalGet(lowBits, i32), builder->makeConst(Literal(int32_t(31))))); } else { - loadHigh = builder->makeSetLocal(highBits, + loadHigh = builder->makeLocalSet(highBits, builder->makeConst(Literal(int32_t(0)))); } curr->type = i32; curr->bytes = std::min(curr->bytes, uint8_t(4)); curr->align = std::min(uint32_t(curr->align), uint32_t(4)); - curr->ptr = builder->makeGetLocal(ptrTemp, i32); + curr->ptr = builder->makeLocalGet(ptrTemp, i32); Block* result = builder->blockify(setPtr, - builder->makeSetLocal(lowBits, curr), + builder->makeLocalSet(lowBits, curr), loadHigh, - builder->makeGetLocal(lowBits, i32)); + builder->makeLocalGet(lowBits, i32)); replaceCurrent(result); setOutParam(result, std::move(highBits)); } @@ -414,15 +414,15 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { curr->valueType = i32; if (bytes == 8) { TempVar ptrTemp = getTemp(); - SetLocal* setPtr = builder->makeSetLocal(ptrTemp, curr->ptr); - curr->ptr = builder->makeGetLocal(ptrTemp, i32); + LocalSet* setPtr = builder->makeLocalSet(ptrTemp, curr->ptr); + curr->ptr = builder->makeLocalGet(ptrTemp, i32); curr->finalize(); Store* storeHigh = builder->makeStore(4, curr->offset + 4, std::min(uint32_t(curr->align), uint32_t(4)), - builder->makeGetLocal(ptrTemp, i32), - builder->makeGetLocal(highBits, i32), + builder->makeLocalGet(ptrTemp, i32), + builder->makeLocalGet(highBits, i32), i32); replaceCurrent(builder->blockify(setPtr, curr, storeHigh)); } @@ -446,8 +446,8 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar highBits = getTemp(); Const* lowVal = builder->makeConst(Literal(int32_t(curr->value.geti64() & 0xffffffff))); - SetLocal* setHigh = - builder->makeSetLocal(highBits, + LocalSet* setHigh = + builder->makeLocalSet(highBits, builder->makeConst(Literal( int32_t(uint64_t(curr->value.geti64()) >> 32)))); Block* result = builder->blockify(setHigh, lowVal); @@ -461,7 +461,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { auto* result = builder->makeUnary( EqZInt32, builder->makeBinary( - OrInt32, curr->value, builder->makeGetLocal(highBits, i32))); + OrInt32, curr->value, builder->makeLocalGet(highBits, i32))); replaceCurrent(result); } @@ -469,7 +469,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { void lowerExtendUInt32(Unary* curr) { TempVar highBits = getTemp(); Block* result = builder->blockify( - builder->makeSetLocal(highBits, builder->makeConst(Literal(int32_t(0)))), + builder->makeLocalSet(highBits, builder->makeConst(Literal(int32_t(0)))), curr->value); setOutParam(result, std::move(highBits)); replaceCurrent(result); @@ -479,15 +479,15 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar highBits = getTemp(); TempVar lowBits = getTemp(); - SetLocal* setLow = builder->makeSetLocal(lowBits, curr->value); - SetLocal* setHigh = builder->makeSetLocal( + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); + LocalSet* setHigh = builder->makeLocalSet( highBits, builder->makeBinary(ShrSInt32, - builder->makeGetLocal(lowBits, i32), + builder->makeLocalGet(lowBits, i32), builder->makeConst(Literal(int32_t(31))))); Block* result = - builder->blockify(setLow, setHigh, builder->makeGetLocal(lowBits, i32)); + builder->blockify(setLow, setHigh, builder->makeLocalGet(lowBits, i32)); setOutParam(result, std::move(highBits)); replaceCurrent(result); @@ -505,7 +505,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar highBits = getTemp(); Block* result = builder->blockify( builder->makeCall(ABI::wasm2js::SCRATCH_STORE_F64, {curr->value}, none), - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_I32, {builder->makeConst(Literal(int32_t(1)))}, @@ -529,7 +529,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { none), builder->makeCall(ABI::wasm2js::SCRATCH_STORE_I32, {builder->makeConst(Literal(int32_t(1))), - builder->makeGetLocal(highBits, i32)}, + builder->makeLocalGet(highBits, i32)}, none), builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_F64, {}, f64)); replaceCurrent(result); @@ -606,7 +606,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { builder->makeUnary( floor, builder->makeBinary(div, - builder->makeGetLocal(f, localType), + builder->makeLocalGet(f, localType), builder->makeConst(u32Max))), builder->makeBinary( sub, builder->makeConst(u32Max), builder->makeConst(litOne))); @@ -616,28 +616,28 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { div, builder->makeBinary( sub, - builder->makeGetLocal(f, localType), + builder->makeLocalGet(f, localType), builder->makeUnary( convert, - builder->makeUnary(trunc, builder->makeGetLocal(f, localType)))), + builder->makeUnary(trunc, builder->makeLocalGet(f, localType)))), builder->makeConst(u32Max))); If* highBitsCalc = builder->makeIf( builder->makeBinary( - gt, builder->makeGetLocal(f, localType), builder->makeConst(litZero)), + gt, builder->makeLocalGet(f, localType), builder->makeConst(litZero)), builder->makeUnary(trunc, gtZeroBranch), builder->makeUnary(trunc, ltZeroBranch)); If* highBitsVal = builder->makeIf( builder->makeBinary( ge, - builder->makeUnary(abs, builder->makeGetLocal(f, localType)), + builder->makeUnary(abs, builder->makeLocalGet(f, localType)), builder->makeConst(litOne)), highBitsCalc, builder->makeConst(Literal(int32_t(0)))); Block* result = builder->blockify( - builder->makeSetLocal(f, curr->value), - builder->makeSetLocal(highBits, highBitsVal), - builder->makeUnary(trunc, builder->makeGetLocal(f, localType))); + builder->makeLocalSet(f, curr->value), + builder->makeLocalSet(highBits, highBitsVal), + builder->makeUnary(trunc, builder->makeLocalGet(f, localType))); setOutParam(result, std::move(highBits)); replaceCurrent(result); } @@ -674,18 +674,18 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } Expression* result = builder->blockify( - builder->makeSetLocal(lowBits, curr->value), - builder->makeSetLocal(highResult, + builder->makeLocalSet(lowBits, curr->value), + builder->makeLocalSet(highResult, builder->makeConst(Literal(int32_t(0)))), builder->makeBinary( AddFloat64, builder->makeUnary(ConvertUInt32ToFloat64, - builder->makeGetLocal(lowBits, i32)), + builder->makeLocalGet(lowBits, i32)), builder->makeBinary( MulFloat64, builder->makeConst(Literal((double)UINT_MAX + 1)), builder->makeUnary(convertHigh, - builder->makeGetLocal(highBits, i32))))); + builder->makeLocalGet(highBits, i32))))); switch (curr->op) { case ConvertSInt64ToFloat32: @@ -707,24 +707,24 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar&& second) { TempVar highResult = getTemp(); TempVar firstResult = getTemp(); - SetLocal* setFirst = builder->makeSetLocal( + LocalSet* setFirst = builder->makeLocalSet( firstResult, - builder->makeUnary(op32, builder->makeGetLocal(first, i32))); + builder->makeUnary(op32, builder->makeLocalGet(first, i32))); Binary* check = builder->makeBinary(EqInt32, - builder->makeGetLocal(firstResult, i32), + builder->makeLocalGet(firstResult, i32), builder->makeConst(Literal(int32_t(32)))); If* conditional = builder->makeIf( check, builder->makeBinary( AddInt32, - builder->makeUnary(op32, builder->makeGetLocal(second, i32)), + builder->makeUnary(op32, builder->makeLocalGet(second, i32)), builder->makeConst(Literal(int32_t(32)))), - builder->makeGetLocal(firstResult, i32)); + builder->makeLocalGet(firstResult, i32)); - SetLocal* setHigh = builder->makeSetLocal( + LocalSet* setHigh = builder->makeLocalSet( highResult, builder->makeConst(Literal(int32_t(0)))); setOutParam(result, std::move(highResult)); @@ -734,7 +734,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar highBits = fetchOutParam(curr->value); TempVar lowBits = getTemp(); - SetLocal* setLow = builder->makeSetLocal(lowBits, curr->value); + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); Block* result = builder->blockify(setLow); switch (curr->op) { @@ -834,27 +834,27 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar&& rightHigh) { TempVar lowResult = getTemp(); TempVar highResult = getTemp(); - SetLocal* addLow = builder->makeSetLocal( + LocalSet* addLow = builder->makeLocalSet( lowResult, builder->makeBinary(AddInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32))); - SetLocal* addHigh = builder->makeSetLocal( + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32))); + LocalSet* addHigh = builder->makeLocalSet( highResult, builder->makeBinary(AddInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32))); - SetLocal* carryBit = builder->makeSetLocal( + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32))); + LocalSet* carryBit = builder->makeLocalSet( highResult, builder->makeBinary(AddInt32, - builder->makeGetLocal(highResult, i32), + builder->makeLocalGet(highResult, i32), builder->makeConst(Literal(int32_t(1))))); If* checkOverflow = builder->makeIf(builder->makeBinary(LtUInt32, - builder->makeGetLocal(lowResult, i32), - builder->makeGetLocal(rightLow, i32)), + builder->makeLocalGet(lowResult, i32), + builder->makeLocalGet(rightLow, i32)), carryBit); - GetLocal* getLow = builder->makeGetLocal(lowResult, i32); + LocalGet* getLow = builder->makeLocalGet(lowResult, i32); result = builder->blockify(result, addLow, addHigh, checkOverflow, getLow); setOutParam(result, std::move(highResult)); return result; @@ -868,27 +868,27 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar lowResult = getTemp(); TempVar highResult = getTemp(); TempVar borrow = getTemp(); - SetLocal* subLow = builder->makeSetLocal( + LocalSet* subLow = builder->makeLocalSet( lowResult, builder->makeBinary(SubInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32))); - SetLocal* borrowBit = builder->makeSetLocal( + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32))); + LocalSet* borrowBit = builder->makeLocalSet( borrow, builder->makeBinary(LtUInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32))); - SetLocal* subHigh1 = builder->makeSetLocal( + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32))); + LocalSet* subHigh1 = builder->makeLocalSet( highResult, builder->makeBinary(AddInt32, - builder->makeGetLocal(borrow, i32), - builder->makeGetLocal(rightHigh, i32))); - SetLocal* subHigh2 = builder->makeSetLocal( + builder->makeLocalGet(borrow, i32), + builder->makeLocalGet(rightHigh, i32))); + LocalSet* subHigh2 = builder->makeLocalSet( highResult, builder->makeBinary(SubInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(highResult, i32))); - GetLocal* getLow = builder->makeGetLocal(lowResult, i32); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(highResult, i32))); + LocalGet* getLow = builder->makeLocalGet(lowResult, i32); result = builder->blockify(result, subLow, borrowBit, subHigh1, subHigh2, getLow); setOutParam(result, std::move(highResult)); @@ -917,25 +917,25 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } result = builder->blockify( result, - builder->makeSetLocal( + builder->makeLocalSet( rightHigh, builder->makeBinary(op32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32))), + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32))), builder->makeBinary(op32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32))); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32))); setOutParam(result, std::move(rightHigh)); return result; } Block* makeLargeShl(Index highBits, Index leftLow, Index shift) { return builder->blockify( - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeBinary(ShlInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(shift, i32))), + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(shift, i32))), builder->makeConst(Literal(int32_t(0)))); } @@ -947,22 +947,22 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { // lo = leftHigh >> (b - 32) Block* makeLargeShrS(Index highBits, Index leftHigh, Index shift) { return builder->blockify( - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeBinary(ShrSInt32, - builder->makeGetLocal(leftHigh, i32), + builder->makeLocalGet(leftHigh, i32), builder->makeConst(Literal(int32_t(31))))), builder->makeBinary(ShrSInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(shift, i32))); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(shift, i32))); } Block* makeLargeShrU(Index highBits, Index leftHigh, Index shift) { return builder->blockify( - builder->makeSetLocal(highBits, builder->makeConst(Literal(int32_t(0)))), + builder->makeLocalSet(highBits, builder->makeConst(Literal(int32_t(0)))), builder->makeBinary(ShrUInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(shift, i32))); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(shift, i32))); } Block* makeSmallShl(Index highBits, @@ -975,17 +975,17 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { AndInt32, shiftMask, builder->makeBinary( - ShrUInt32, builder->makeGetLocal(leftLow, i32), widthLessShift)); + ShrUInt32, builder->makeLocalGet(leftLow, i32), widthLessShift)); Binary* shiftHigh = builder->makeBinary(ShlInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(shift, i32)); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(shift, i32)); return builder->blockify( - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeBinary(OrInt32, shiftedInBits, shiftHigh)), builder->makeBinary(ShlInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(shift, i32))); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(shift, i32))); } // a >> b where `b` < 32 @@ -1003,17 +1003,17 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { Binary* shiftedInBits = builder->makeBinary( ShlInt32, builder->makeBinary( - AndInt32, shiftMask, builder->makeGetLocal(leftHigh, i32)), + AndInt32, shiftMask, builder->makeLocalGet(leftHigh, i32)), widthLessShift); Binary* shiftLow = builder->makeBinary(ShrUInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(shift, i32)); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(shift, i32)); return builder->blockify( - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeBinary(ShrSInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(shift, i32))), + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(shift, i32))), builder->makeBinary(OrInt32, shiftedInBits, shiftLow)); } @@ -1026,17 +1026,17 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { Binary* shiftedInBits = builder->makeBinary( ShlInt32, builder->makeBinary( - AndInt32, shiftMask, builder->makeGetLocal(leftHigh, i32)), + AndInt32, shiftMask, builder->makeLocalGet(leftHigh, i32)), widthLessShift); Binary* shiftLow = builder->makeBinary(ShrUInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(shift, i32)); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(shift, i32)); return builder->blockify( - builder->makeSetLocal( + builder->makeLocalSet( highBits, builder->makeBinary(ShrUInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(shift, i32))), + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(shift, i32))), builder->makeBinary(OrInt32, shiftedInBits, shiftLow)); } @@ -1055,16 +1055,16 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { // low = leftLow << k // where k = shift % 32. shift right is similar. TempVar shift = getTemp(); - SetLocal* setShift = builder->makeSetLocal( + LocalSet* setShift = builder->makeLocalSet( shift, builder->makeBinary(AndInt32, - builder->makeGetLocal(rightLow, i32), + builder->makeLocalGet(rightLow, i32), builder->makeConst(Literal(int32_t(32 - 1))))); Binary* isLargeShift = builder->makeBinary( LeUInt32, builder->makeConst(Literal(int32_t(32))), builder->makeBinary(AndInt32, - builder->makeGetLocal(rightLow, i32), + builder->makeLocalGet(rightLow, i32), builder->makeConst(Literal(int32_t(64 - 1))))); Block* largeShiftBlock; switch (op) { @@ -1084,12 +1084,12 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { SubInt32, builder->makeBinary(ShlInt32, builder->makeConst(Literal(int32_t(1))), - builder->makeGetLocal(shift, i32)), + builder->makeLocalGet(shift, i32)), builder->makeConst(Literal(int32_t(1)))); Binary* widthLessShift = builder->makeBinary(SubInt32, builder->makeConst(Literal(int32_t(32))), - builder->makeGetLocal(shift, i32)); + builder->makeLocalGet(shift, i32)); Block* smallShiftBlock; switch (op) { case ShlInt64: { @@ -1127,11 +1127,11 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { builder->makeBinary( AndInt32, builder->makeBinary(EqInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32)), + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32)), builder->makeBinary(EqInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)))); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)))); } Block* lowerNe(Block* result, @@ -1144,11 +1144,11 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { builder->makeBinary( OrInt32, builder->makeBinary(NeInt32, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32)), + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32)), builder->makeBinary(NeInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)))); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)))); } Block* lowerUComp(BinaryOp op, @@ -1180,14 +1180,14 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } Binary* compHigh = builder->makeBinary(highOp, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)); Binary* eqHigh = builder->makeBinary(EqInt32, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)); Binary* compLow = builder->makeBinary(lowOp, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32)); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32)); return builder->blockify( result, builder->makeBinary( @@ -1227,15 +1227,15 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } Binary* compHigh1 = builder->makeBinary(highOp1, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)); Binary* compHigh2 = builder->makeBinary(highOp2, - builder->makeGetLocal(leftHigh, i32), - builder->makeGetLocal(rightHigh, i32)); + builder->makeLocalGet(leftHigh, i32), + builder->makeLocalGet(rightHigh, i32)); Binary* compLow = builder->makeBinary(lowOp, - builder->makeGetLocal(leftLow, i32), - builder->makeGetLocal(rightLow, i32)); + builder->makeLocalGet(leftLow, i32), + builder->makeLocalGet(rightLow, i32)); If* lowIf = builder->makeIf(compLow, builder->makeConst(Literal(int32_t(0))), builder->makeConst(Literal(int32_t(1)))); @@ -1291,8 +1291,8 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar leftHigh = fetchOutParam(curr->left); TempVar rightLow = getTemp(); TempVar rightHigh = fetchOutParam(curr->right); - SetLocal* setRight = builder->makeSetLocal(rightLow, curr->right); - SetLocal* setLeft = builder->makeSetLocal(leftLow, curr->left); + LocalSet* setRight = builder->makeLocalSet(rightLow, curr->right); + LocalSet* setLeft = builder->makeLocalSet(leftLow, curr->left); Block* result = builder->blockify(setLeft, setRight); switch (curr->op) { case AddInt64: { @@ -1403,18 +1403,18 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { TempVar lowBits = getTemp(); TempVar cond = getTemp(); Block* result = builder->blockify( - builder->makeSetLocal(cond, curr->condition), - builder->makeSetLocal( + builder->makeLocalSet(cond, curr->condition), + builder->makeLocalSet( lowBits, builder->makeSelect( - builder->makeGetLocal(cond, i32), curr->ifTrue, curr->ifFalse)), - builder->makeSetLocal( + builder->makeLocalGet(cond, i32), curr->ifTrue, curr->ifFalse)), + builder->makeLocalSet( highBits, builder->makeSelect( - builder->makeGetLocal(cond, i32), - builder->makeGetLocal(fetchOutParam(curr->ifTrue), i32), - builder->makeGetLocal(fetchOutParam(curr->ifFalse), i32))), - builder->makeGetLocal(lowBits, i32)); + builder->makeLocalGet(cond, i32), + builder->makeLocalGet(fetchOutParam(curr->ifTrue), i32), + builder->makeLocalGet(fetchOutParam(curr->ifFalse), i32))), + builder->makeLocalGet(lowBits, i32)); setOutParam(result, std::move(highBits)); replaceCurrent(result); } @@ -1433,10 +1433,10 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { } TempVar lowBits = getTemp(); TempVar highBits = fetchOutParam(curr->value); - SetLocal* setLow = builder->makeSetLocal(lowBits, curr->value); - SetGlobal* setHigh = builder->makeSetGlobal( - INT64_TO_32_HIGH_BITS, builder->makeGetLocal(highBits, i32)); - curr->value = builder->makeGetLocal(lowBits, i32); + LocalSet* setLow = builder->makeLocalSet(lowBits, curr->value); + GlobalSet* setHigh = builder->makeGlobalSet( + INT64_TO_32_HIGH_BITS, builder->makeLocalGet(highBits, i32)); + curr->value = builder->makeLocalGet(lowBits, i32); Block* result = builder->blockify(setLow, setHigh, curr); replaceCurrent(result); } diff --git a/src/passes/Inlining.cpp b/src/passes/Inlining.cpp index 11f452e17..04e82579c 100644 --- a/src/passes/Inlining.cpp +++ b/src/passes/Inlining.cpp @@ -199,10 +199,10 @@ doInlining(Module* module, Function* into, InliningAction& action) { void visitReturn(Return* curr) { replaceCurrent(builder->makeBreak(returnName, curr->value)); } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { curr->index = localMapping[curr->index]; } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { curr->index = localMapping[curr->index]; } } updater; @@ -214,13 +214,13 @@ doInlining(Module* module, Function* into, InliningAction& action) { // assign the operands into the params for (Index i = 0; i < from->params.size(); i++) { block->list.push_back( - builder.makeSetLocal(updater.localMapping[i], call->operands[i])); + builder.makeLocalSet(updater.localMapping[i], call->operands[i])); } // zero out the vars (as we may be in a loop, and may depend on their // zero-init value for (Index i = 0; i < from->vars.size(); i++) { block->list.push_back( - builder.makeSetLocal(updater.localMapping[from->getVarIndexBase() + i], + builder.makeLocalSet(updater.localMapping[from->getVarIndexBase() + i], LiteralUtils::makeZero(from->vars[i], *module))); } // generate and update the inlined contents diff --git a/src/passes/InstrumentLocals.cpp b/src/passes/InstrumentLocals.cpp index 45d4d484b..32623a432 100644 --- a/src/passes/InstrumentLocals.cpp +++ b/src/passes/InstrumentLocals.cpp @@ -64,7 +64,7 @@ Name set_f32("set_f32"); Name set_f64("set_f64"); struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> { - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { Builder builder(*getModule()); Name import; switch (curr->type) { @@ -96,7 +96,7 @@ struct InstrumentLocals : public WalkerPass<PostWalker<InstrumentLocals>> { curr->type)); } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { Builder builder(*getModule()); Name import; switch (curr->value->type) { diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp index ad6d0c35b..23cceb4ef 100644 --- a/src/passes/LegalizeJSInterface.cpp +++ b/src/passes/LegalizeJSInterface.cpp @@ -176,7 +176,7 @@ private: legal->params.push_back(i32); } else { call->operands.push_back( - builder.makeGetLocal(legal->params.size(), param)); + builder.makeLocalGet(legal->params.size(), param)); legal->params.push_back(param); } } @@ -186,7 +186,7 @@ private: legal->result = i32; auto index = Builder::addVar(legal, Name(), i64); auto* block = builder.makeBlock(); - block->list.push_back(builder.makeSetLocal(index, call)); + block->list.push_back(builder.makeLocalSet(index, call)); block->list.push_back(builder.makeCall( f->name, {I64Utilities::getI64High(builder, index)}, none)); block->list.push_back(I64Utilities::getI64Low(builder, index)); @@ -233,7 +233,7 @@ private: type->params.push_back(i32); } else { call->operands.push_back( - builder.makeGetLocal(func->params.size(), param)); + builder.makeLocalGet(func->params.size(), param)); type->params.push_back(param); } func->params.push_back(param); diff --git a/src/passes/LocalCSE.cpp b/src/passes/LocalCSE.cpp index d582c8275..f3e03d95d 100644 --- a/src/passes/LocalCSE.cpp +++ b/src/passes/LocalCSE.cpp @@ -114,7 +114,7 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> { // the loop above - just the values. So here we must check that // sets do not interfere. (Note that due to flattening we // have no risk of tees etc.) - if (auto* set = curr->dynCast<SetLocal>()) { + if (auto* set = curr->dynCast<LocalSet>()) { for (auto& sinkable : usables) { // Check if the index is the same. Make sure to ignore // our own value, which we may have just added! @@ -170,10 +170,10 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> { } void handle(Expression* curr) { - if (auto* set = curr->dynCast<SetLocal>()) { + if (auto* set = curr->dynCast<LocalSet>()) { // Calculate equivalences equivalences.reset(set->index); - if (auto* get = set->value->dynCast<GetLocal>()) { + if (auto* get = set->value->dynCast<LocalGet>()) { equivalences.add(set->index, get->index); } // consider the value @@ -185,7 +185,7 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> { // already exists in the table, this is good to reuse auto& info = iter->second; set->value = - Builder(*getModule()).makeGetLocal(info.index, value->type); + Builder(*getModule()).makeLocalGet(info.index, value->type); anotherPass = true; } else { // not in table, add this, maybe we can help others later @@ -193,7 +193,7 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> { hashed, UsableInfo(value, set->index, getPassOptions()))); } } - } else if (auto* get = curr->dynCast<GetLocal>()) { + } else if (auto* get = curr->dynCast<LocalGet>()) { if (auto* set = equivalences.getEquivalents(get->index)) { // Canonicalize to the lowest index. This lets hashing and comparisons // "just work". @@ -205,7 +205,7 @@ struct LocalCSE : public WalkerPass<LinearExecutionWalker<LocalCSE>> { // A relevant value is a non-trivial one, something we may want to reuse // and are able to. bool isRelevant(Expression* value) { - if (value->is<GetLocal>()) { + if (value->is<LocalGet>()) { return false; // trivial, this is what we optimize to! } if (!isConcreteType(value->type)) { diff --git a/src/passes/LoopInvariantCodeMotion.cpp b/src/passes/LoopInvariantCodeMotion.cpp index b8e00ffce..c4880114d 100644 --- a/src/passes/LoopInvariantCodeMotion.cpp +++ b/src/passes/LoopInvariantCodeMotion.cpp @@ -39,7 +39,7 @@ struct LoopInvariantCodeMotion Pass* create() override { return new LoopInvariantCodeMotion; } - typedef std::unordered_set<SetLocal*> LoopSets; + typedef std::unordered_set<LocalSet*> LoopSets; // main entry point @@ -78,7 +78,7 @@ struct LoopInvariantCodeMotion std::fill(numSetsForIndex.begin(), numSetsForIndex.end(), 0); LoopSets loopSets; { - FindAll<SetLocal> finder(loop); + FindAll<LocalSet> finder(loop); for (auto* set : finder.list) { numSetsForIndex[set->index]++; loopSets.insert(set); @@ -135,7 +135,7 @@ struct LoopInvariantCodeMotion // and must also check if our sets interfere with them. To do so, // assume temporarily that we are moving curr out; see if any sets // remain for its indexes. - FindAll<SetLocal> currSets(curr); + FindAll<LocalSet> currSets(curr); for (auto* set : currSets.list) { assert(numSetsForIndex[set->index] > 0); numSetsForIndex[set->index]--; @@ -205,15 +205,15 @@ struct LoopInvariantCodeMotion // it is beneficial to run this pass later on (but that has downsides // too, as with more nesting moving code is harder - so something // like -O --flatten --licm -O may be best). - if (auto* set = curr->dynCast<SetLocal>()) { + if (auto* set = curr->dynCast<LocalSet>()) { while (1) { - auto* next = set->value->dynCast<SetLocal>(); + auto* next = set->value->dynCast<LocalSet>(); if (!next) { break; } set = next; } - if (set->value->is<GetLocal>() || set->value->is<Const>()) { + if (set->value->is<LocalGet>() || set->value->is<Const>()) { return false; } } @@ -221,7 +221,7 @@ struct LoopInvariantCodeMotion } bool hasGetDependingOnLoopSet(Expression* curr, LoopSets& loopSets) { - FindAll<GetLocal> gets(curr); + FindAll<LocalGet> gets(curr); for (auto* get : gets.list) { auto& sets = localGraph->getSetses[get]; for (auto* set : sets) { diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp index 973f17eec..bba64c381 100644 --- a/src/passes/MergeBlocks.cpp +++ b/src/passes/MergeBlocks.cpp @@ -476,7 +476,7 @@ struct MergeBlocks : public WalkerPass<PostWalker<MergeBlocks>> { } void visitUnary(Unary* curr) { optimize(curr, curr->value); } - void visitSetLocal(SetLocal* curr) { optimize(curr, curr->value); } + void visitLocalSet(LocalSet* curr) { optimize(curr, curr->value); } void visitLoad(Load* curr) { optimize(curr, curr->ptr); } void visitReturn(Return* curr) { optimize(curr, curr->value); } diff --git a/src/passes/MergeLocals.cpp b/src/passes/MergeLocals.cpp index e8d42e8dd..c20105621 100644 --- a/src/passes/MergeLocals.cpp +++ b/src/passes/MergeLocals.cpp @@ -82,13 +82,13 @@ struct MergeLocals optimizeCopies(); } - std::vector<SetLocal*> copies; + std::vector<LocalSet*> copies; - void visitSetLocal(SetLocal* curr) { - if (auto* get = curr->value->dynCast<GetLocal>()) { + void visitLocalSet(LocalSet* curr) { + if (auto* get = curr->value->dynCast<LocalGet>()) { if (get->index != curr->index) { Builder builder(*getModule()); - auto* trivial = builder.makeTeeLocal(get->index, get); + auto* trivial = builder.makeLocalTee(get->index, get); curr->value = trivial; copies.push_back(curr); } @@ -103,10 +103,10 @@ struct MergeLocals LocalGraph preGraph(getFunction()); preGraph.computeInfluences(); // optimize each copy - std::unordered_map<SetLocal*, SetLocal*> optimizedToCopy, + std::unordered_map<LocalSet*, LocalSet*> optimizedToCopy, optimizedToTrivial; for (auto* copy : copies) { - auto* trivial = copy->value->cast<SetLocal>(); + auto* trivial = copy->value->cast<LocalSet>(); bool canOptimizeToCopy = false; auto& trivialInfluences = preGraph.setInfluences[trivial]; if (!trivialInfluences.empty()) { @@ -215,7 +215,7 @@ struct MergeLocals } // remove the trivial sets for (auto* copy : copies) { - copy->value = copy->value->cast<SetLocal>()->value; + copy->value = copy->value->cast<LocalSet>()->value; } } }; diff --git a/src/passes/OptimizeAddedConstants.cpp b/src/passes/OptimizeAddedConstants.cpp index b8d011cfb..8a72a0cd0 100644 --- a/src/passes/OptimizeAddedConstants.cpp +++ b/src/passes/OptimizeAddedConstants.cpp @@ -76,7 +76,7 @@ public: // load(y, offset=10) // // This is only valid if y does not change in the middle! - if (auto* get = curr->ptr->template dynCast<GetLocal>()) { + if (auto* get = curr->ptr->template dynCast<LocalGet>()) { auto& sets = localGraph->getSetses[get]; if (sets.size() == 1) { auto* set = *sets.begin(); @@ -159,8 +159,8 @@ private: bool tryToOptimizePropagatedAdd(Expression* oneSide, Expression* otherSide, - GetLocal* ptr, - SetLocal* set) { + LocalGet* ptr, + LocalSet* set) { if (auto* c = oneSide->template dynCast<Const>()) { if (otherSide->template is<Const>()) { // Both sides are constant - this is not optimized code, ignore. @@ -191,7 +191,7 @@ private: // dominates the load, and it is ok to replace x with y + 10 there. Index index = -1; bool canReuseIndex = false; - if (auto* get = otherSide->template dynCast<GetLocal>()) { + if (auto* get = otherSide->template dynCast<LocalGet>()) { if (localGraph->isSSA(get->index) && localGraph->isSSA(ptr->index)) { index = get->index; canReuseIndex = true; @@ -213,7 +213,7 @@ private: index = parent->getHelperIndex(set); } curr->offset = result.total; - curr->ptr = Builder(*module).makeGetLocal(index, i32); + curr->ptr = Builder(*module).makeLocalGet(index, i32); return true; } } @@ -298,7 +298,7 @@ struct OptimizeAddedConstants // the expression, but the set in which it is in, as the arm of an add that is // the set's value (the other arm is a constant, and we are not a constant). // We cache these, that is, use a single one for all requests. - Index getHelperIndex(SetLocal* set) { + Index getHelperIndex(LocalSet* set) { auto iter = helperIndexes.find(set); if (iter != helperIndexes.end()) { return iter->second; @@ -307,7 +307,7 @@ struct OptimizeAddedConstants Builder(*getModule()).addVar(getFunction(), i32); } - bool isPropagatable(SetLocal* set) { return propagatable.count(set); } + bool isPropagatable(LocalSet* set) { return propagatable.count(set); } private: bool propagated; @@ -315,7 +315,7 @@ private: std::unique_ptr<LocalGraph> localGraph; // Whether a set is propagatable. - std::set<SetLocal*> propagatable; + std::set<LocalSet*> propagatable; void findPropagatable() { // Conservatively, only propagate if all uses can be removed of the @@ -331,7 +331,7 @@ private: Parents parents(getFunction()->body); for (auto& pair : localGraph->locations) { auto* location = pair.first; - if (auto* set = location->dynCast<SetLocal>()) { + if (auto* set = location->dynCast<LocalSet>()) { if (auto* add = set->value->dynCast<Binary>()) { if (add->op == AddInt32) { if (add->left->is<Const>() || add->right->is<Const>()) { @@ -363,17 +363,17 @@ private: UnneededSetRemover remover(getFunction(), getPassOptions()); } - std::map<SetLocal*, Index> helperIndexes; + std::map<LocalSet*, Index> helperIndexes; void createHelperIndexes() { struct Creator : public PostWalker<Creator> { - std::map<SetLocal*, Index>& helperIndexes; + std::map<LocalSet*, Index>& helperIndexes; Module* module; - Creator(std::map<SetLocal*, Index>& helperIndexes) + Creator(std::map<LocalSet*, Index>& helperIndexes) : helperIndexes(helperIndexes) {} - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { auto iter = helperIndexes.find(curr); if (iter != helperIndexes.end()) { auto index = iter->second; @@ -387,9 +387,9 @@ private: } auto* value = *target; Builder builder(*module); - *target = builder.makeGetLocal(index, i32); + *target = builder.makeLocalGet(index, i32); replaceCurrent( - builder.makeSequence(builder.makeSetLocal(index, value), curr)); + builder.makeSequence(builder.makeLocalSet(index, value), curr)); } } } creator(helperIndexes); diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp index 85258dbb8..cf764ac49 100644 --- a/src/passes/OptimizeInstructions.cpp +++ b/src/passes/OptimizeInstructions.cpp @@ -166,10 +166,10 @@ Index getMaxBits(Expression* curr, LocalInfoProvider* localInfoProvider) { return std::min(Index(32), getMaxBits(unary->value, localInfoProvider)); default: {} } - } else if (auto* set = curr->dynCast<SetLocal>()) { + } else if (auto* set = curr->dynCast<LocalSet>()) { // a tee passes through the value return getMaxBits(set->value, localInfoProvider); - } else if (auto* get = curr->dynCast<GetLocal>()) { + } else if (auto* get = curr->dynCast<LocalGet>()) { return localInfoProvider->getMaxBitsForLocal(get); } else if (auto* load = curr->dynCast<Load>()) { // if signed, then the sign-extension might fill all the bits @@ -226,7 +226,7 @@ struct LocalScanner : PostWalker<LocalScanner> { } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { auto* func = getFunction(); if (func->isParam(curr->index)) { return; @@ -257,7 +257,7 @@ struct LocalScanner : PostWalker<LocalScanner> { // define this for the templated getMaxBits method. we know nothing here yet // about locals, so return the maxes - Index getMaxBitsForLocal(GetLocal* get) { return getBitsForType(get->type); } + Index getMaxBitsForLocal(LocalGet* get) { return getBitsForType(get->type); } Index getBitsForType(Type type) { switch (type) { @@ -728,9 +728,9 @@ struct OptimizeInstructions return unary; } } - } else if (auto* set = curr->dynCast<SetGlobal>()) { + } else if (auto* set = curr->dynCast<GlobalSet>()) { // optimize out a set of a get - auto* get = set->value->dynCast<GetGlobal>(); + auto* get = set->value->dynCast<GlobalGet>(); if (get && get->name == set->name) { ExpressionManipulator::nop(curr); } @@ -874,7 +874,7 @@ struct OptimizeInstructions return nullptr; } - Index getMaxBitsForLocal(GetLocal* get) { + Index getMaxBitsForLocal(LocalGet* get) { // check what we know about the local return localInfo[get->index].maxBits; } @@ -906,7 +906,7 @@ private: return; } // Prefer a get on the right. - if (binary->left->is<GetLocal>() && !binary->right->is<GetLocal>()) { + if (binary->left->is<LocalGet>() && !binary->right->is<LocalGet>()) { return maybeSwap(); } // Sort by the node id type, if different. @@ -929,8 +929,8 @@ private: return maybeSwap(); } } - if (auto* left = binary->left->dynCast<GetLocal>()) { - auto* right = binary->right->cast<GetLocal>(); + if (auto* left = binary->left->dynCast<LocalGet>()) { + auto* right = binary->right->cast<LocalGet>(); if (left->index > right->index) { return maybeSwap(); } @@ -1270,7 +1270,7 @@ private: if (Properties::getSignExtValue(curr)) { return Properties::getSignExtBits(curr) == bits; } - if (auto* get = curr->dynCast<GetLocal>()) { + if (auto* get = curr->dynCast<LocalGet>()) { // check what we know about the local return localInfo[get->index].signExtedBits == bits; } diff --git a/src/passes/PickLoadSigns.cpp b/src/passes/PickLoadSigns.cpp index f494159a1..c3b5a2ba2 100644 --- a/src/passes/PickLoadSigns.cpp +++ b/src/passes/PickLoadSigns.cpp @@ -51,7 +51,7 @@ struct PickLoadSigns : public WalkerPass<ExpressionStackWalker<PickLoadSigns>> { optimize(); } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { // this is a use. check from the context what it is, signed or unsigned, // etc. auto& usage = usages[curr->index]; @@ -81,7 +81,7 @@ struct PickLoadSigns : public WalkerPass<ExpressionStackWalker<PickLoadSigns>> { } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (curr->isTee()) { // we can't modify a tee, the value is used elsewhere return; diff --git a/src/passes/PostEmscripten.cpp b/src/passes/PostEmscripten.cpp index cc4b03a7f..9d2b41094 100644 --- a/src/passes/PostEmscripten.cpp +++ b/src/passes/PostEmscripten.cpp @@ -48,7 +48,7 @@ struct PostEmscripten : public WalkerPass<PostWalker<PostEmscripten>> { replaceCurrent(builder.makeBinary( MulFloat64, localizer.expr, - builder.makeGetLocal(localizer.index, localizer.expr->type))); + builder.makeLocalGet(localizer.index, localizer.expr->type))); } else if (exponent->value == Literal(double(0.5))) { // This is just a square root operation replaceCurrent( diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp index d5cfdc968..2e8c8fe31 100644 --- a/src/passes/Precompute.cpp +++ b/src/passes/Precompute.cpp @@ -41,7 +41,7 @@ namespace wasm { static const Name NOTPRECOMPUTABLE_FLOW("Binaryen|notprecomputable"); -typedef std::unordered_map<GetLocal*, Literal> GetValues; +typedef std::unordered_map<LocalGet*, Literal> GetValues; // Precomputes an expression. Errors if we hit anything that can't be // precomputed. @@ -80,7 +80,7 @@ public: Flow visitCallIndirect(CallIndirect* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } - Flow visitGetLocal(GetLocal* curr) { + Flow visitLocalGet(LocalGet* curr) { auto iter = getValues.find(curr); if (iter != getValues.end()) { auto value = iter->second; @@ -90,7 +90,7 @@ public: } return Flow(NOTPRECOMPUTABLE_FLOW); } - Flow visitSetLocal(SetLocal* curr) { + Flow visitLocalSet(LocalSet* curr) { // If we don't need to replace the whole expression, see if there // is a value flowing through a tee. if (!replaceExpression) { @@ -101,14 +101,14 @@ public: } return Flow(NOTPRECOMPUTABLE_FLOW); } - Flow visitGetGlobal(GetGlobal* curr) { + Flow visitGlobalGet(GlobalGet* curr) { auto* global = module->getGlobal(curr->name); if (!global->imported() && !global->mutable_) { return visit(global->init); } return Flow(NOTPRECOMPUTABLE_FLOW); } - Flow visitSetGlobal(SetGlobal* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } + Flow visitGlobalSet(GlobalSet* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } Flow visitLoad(Load* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } Flow visitStore(Store* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } Flow visitAtomicRMW(AtomicRMW* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); } @@ -296,7 +296,7 @@ private: work.insert(curr); } // the constant value, or none if not a constant - std::unordered_map<SetLocal*, Literal> setValues; + std::unordered_map<LocalSet*, Literal> setValues; // propagate constant values while (!work.empty()) { auto iter = work.begin(); @@ -305,7 +305,7 @@ private: // see if this set or get is actually a constant value, and if so, // mark it as such and add everything it influences to the work list, // as they may be constant too. - if (auto* set = curr->dynCast<SetLocal>()) { + if (auto* set = curr->dynCast<LocalSet>()) { if (setValues[set].isConcrete()) { continue; // already known constant } @@ -317,7 +317,7 @@ private: } } } else { - auto* get = curr->cast<GetLocal>(); + auto* get = curr->cast<LocalGet>(); if (getValues[get].isConcrete()) { continue; // already known constant } diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp index 73d91b9ce..fb85023f0 100644 --- a/src/passes/Print.cpp +++ b/src/passes/Print.cpp @@ -111,10 +111,10 @@ struct PrintExpressionContents : public Visitor<PrintExpressionContents> { void visitCallIndirect(CallIndirect* curr) { printMedium(o, "call_indirect (type ") << curr->fullType << ')'; } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { printMedium(o, "local.get ") << printableLocal(curr->index, currFunction); } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (curr->isTee()) { printMedium(o, "local.tee "); } else { @@ -122,11 +122,11 @@ struct PrintExpressionContents : public Visitor<PrintExpressionContents> { } o << printableLocal(curr->index, currFunction); } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { printMedium(o, "global.get "); printName(curr->name, o); } - void visitSetGlobal(SetGlobal* curr) { + void visitGlobalSet(GlobalSet* curr) { printMedium(o, "global.set "); printName(curr->name, o); } @@ -1140,11 +1140,11 @@ struct PrintExpressionContents : public Visitor<PrintExpressionContents> { void visitReturn(Return* curr) { printMedium(o, "return"); } void visitHost(Host* curr) { switch (curr->op) { - case CurrentMemory: - printMedium(o, "current_memory"); + case MemorySize: + printMedium(o, "memory.size"); break; - case GrowMemory: - printMedium(o, "grow_memory"); + case MemoryGrow: + printMedium(o, "memory.grow"); break; } } @@ -1402,24 +1402,24 @@ struct PrintSExpression : public Visitor<PrintSExpression> { printFullLine(curr->target); decIndent(); } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); o << ')'; } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); incIndent(); printFullLine(curr->value); decIndent(); } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); o << ')'; } - void visitSetGlobal(SetGlobal* curr) { + void visitGlobalSet(GlobalSet* curr) { o << '('; PrintExpressionContents(currFunction, o).visit(curr); incIndent(); @@ -1600,13 +1600,13 @@ struct PrintSExpression : public Visitor<PrintSExpression> { o << '('; PrintExpressionContents(currFunction, o).visit(curr); switch (curr->op) { - case GrowMemory: { + case MemoryGrow: { incIndent(); printFullLine(curr->operands[0]); decIndent(); break; } - case CurrentMemory: { + case MemorySize: { o << ')'; } } diff --git a/src/passes/RedundantSetElimination.cpp b/src/passes/RedundantSetElimination.cpp index bd0e5b890..d881bd9e2 100644 --- a/src/passes/RedundantSetElimination.cpp +++ b/src/passes/RedundantSetElimination.cpp @@ -69,7 +69,7 @@ struct RedundantSetElimination // cfg traversal work - static void doVisitSetLocal(RedundantSetElimination* self, + static void doVisitLocalSet(RedundantSetElimination* self, Expression** currp) { if (self->currBasicBlock) { self->currBasicBlock->contents.setps.push_back(currp); @@ -160,7 +160,7 @@ struct RedundantSetElimination if (auto* c = value->dynCast<Const>()) { // a constant return getLiteralValue(c->value); - } else if (auto* get = value->dynCast<GetLocal>()) { + } else if (auto* get = value->dynCast<LocalGet>()) { // a copy of whatever that was return currValues[get->index]; } else { @@ -292,7 +292,7 @@ struct RedundantSetElimination auto currValues = curr->contents.start; // we'll modify this as we go auto& setps = curr->contents.setps; for (auto** setp : setps) { - auto* set = (*setp)->cast<SetLocal>(); + auto* set = (*setp)->cast<LocalSet>(); currValues[set->index] = getValue(set->value, currValues); } if (currValues == curr->contents.end) { @@ -328,7 +328,7 @@ struct RedundantSetElimination auto currValues = block->contents.start; // we'll modify this as we go auto& setps = block->contents.setps; for (auto** setp : setps) { - auto* set = (*setp)->cast<SetLocal>(); + auto* set = (*setp)->cast<LocalSet>(); auto oldValue = currValues[set->index]; auto newValue = getValue(set->value, currValues); auto index = set->index; @@ -343,10 +343,10 @@ struct RedundantSetElimination } void remove(Expression** setp) { - auto* set = (*setp)->cast<SetLocal>(); + auto* set = (*setp)->cast<LocalSet>(); auto* value = set->value; if (!set->isTee()) { - auto* drop = ExpressionManipulator::convert<SetLocal, Drop>(set); + auto* drop = ExpressionManipulator::convert<LocalSet, Drop>(set); drop->value = value; drop->finalize(); } else { diff --git a/src/passes/RelooperJumpThreading.cpp b/src/passes/RelooperJumpThreading.cpp index 855e89b7f..8dfc1e0e4 100644 --- a/src/passes/RelooperJumpThreading.cpp +++ b/src/passes/RelooperJumpThreading.cpp @@ -48,7 +48,7 @@ static If* isLabelCheckingIf(Expression* curr, Index labelIndex) { if (!(condition && condition->op == EqInt32)) { return nullptr; } - auto* left = condition->left->dynCast<GetLocal>(); + auto* left = condition->left->dynCast<LocalGet>(); if (!(left && left->index == labelIndex)) { return nullptr; } @@ -59,11 +59,11 @@ static Index getCheckedLabelValue(If* iff) { return iff->condition->cast<Binary>()->right->cast<Const>()->value.geti32(); } -static SetLocal* isLabelSettingSetLocal(Expression* curr, Index labelIndex) { +static LocalSet* isLabelSettingLocalSet(Expression* curr, Index labelIndex) { if (!curr) { return nullptr; } - auto* set = curr->dynCast<SetLocal>(); + auto* set = curr->dynCast<LocalSet>(); if (!set) { return nullptr; } @@ -73,7 +73,7 @@ static SetLocal* isLabelSettingSetLocal(Expression* curr, Index labelIndex) { return set; } -static Index getSetLabelValue(SetLocal* set) { +static Index getSetLabelValue(LocalSet* set) { return set->value->cast<Const>()->value.geti32(); } @@ -93,8 +93,8 @@ struct LabelUseFinder : public PostWalker<LabelUseFinder> { } } - void visitSetLocal(SetLocal* curr) { - if (isLabelSettingSetLocal(curr, labelIndex)) { + void visitLocalSet(LocalSet* curr) { + if (isLabelSettingLocalSet(curr, labelIndex)) { sets[getSetLabelValue(curr)]++; } } @@ -247,7 +247,7 @@ private: Index targetNum; Name targetName; - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (curr->index == labelIndex) { if (Index(curr->value->cast<Const>()->value.geti32()) == targetNum) { replaceCurrent(Builder(*getModule()).makeBreak(targetName)); diff --git a/src/passes/RemoveNonJSOps.cpp b/src/passes/RemoveNonJSOps.cpp index dd23aa9bf..a2fe10812 100644 --- a/src/passes/RemoveNonJSOps.cpp +++ b/src/passes/RemoveNonJSOps.cpp @@ -314,7 +314,7 @@ struct RemoveNonJSOpsPass : public WalkerPass<PostWalker<RemoveNonJSOpsPass>> { replaceCurrent(builder->makeCall(functionCall, {curr->value}, curr->type)); } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { neededImportedGlobals.insert(std::make_pair(curr->name, curr->type)); } }; diff --git a/src/passes/RemoveUnusedBrs.cpp b/src/passes/RemoveUnusedBrs.cpp index 20811efef..1e67ecec3 100644 --- a/src/passes/RemoveUnusedBrs.cpp +++ b/src/passes/RemoveUnusedBrs.cpp @@ -269,9 +269,9 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> { Expression* z; replaceCurrent( z = builder.makeIf( - builder.makeTeeLocal(temp, curr->condition), + builder.makeLocalTee(temp, curr->condition), builder.makeIf(builder.makeBinary(EqInt32, - builder.makeGetLocal(temp, i32), + builder.makeLocalGet(temp, i32), builder.makeConst(Literal(int32_t( curr->targets.size() - 1)))), builder.makeBreak(curr->targets.back()), @@ -297,7 +297,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> { } // TODO: if-else can be turned into a br_if as well, if one of the sides is // a dead end we handle the case of a returned value to a local.set - // later down, see visitSetLocal. + // later down, see visitLocalSet. } // override scan to add a pre and a post check task to all nodes @@ -895,7 +895,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> { return nullptr; } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { // Sets of an if can be optimized in various ways that remove part of // the if branching, or all of it. // The optimizations we can do here can recurse and call each @@ -929,7 +929,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> { // ) // TODO: handle a condition in the br? need to watch for side effects bool optimizeSetIfWithBrArm(Expression** currp) { - auto* set = (*currp)->cast<SetLocal>(); + auto* set = (*currp)->cast<LocalSet>(); auto* iff = set->value->dynCast<If>(); if (!iff || !isConcreteType(iff->type) || !isConcreteType(iff->condition->type)) { @@ -1004,18 +1004,18 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> { // merged or eliminated given the outside scope, and we // removed one of the if branches. bool optimizeSetIfWithCopyArm(Expression** currp) { - auto* set = (*currp)->cast<SetLocal>(); + auto* set = (*currp)->cast<LocalSet>(); auto* iff = set->value->dynCast<If>(); if (!iff || !isConcreteType(iff->type) || !isConcreteType(iff->condition->type)) { return false; } Builder builder(*getModule()); - GetLocal* get = iff->ifTrue->dynCast<GetLocal>(); + LocalGet* get = iff->ifTrue->dynCast<LocalGet>(); if (get && get->index == set->index) { builder.flip(iff); } else { - get = iff->ifFalse->dynCast<GetLocal>(); + get = iff->ifFalse->dynCast<LocalGet>(); if (get && get->index != set->index) { get = nullptr; } diff --git a/src/passes/RemoveUnusedModuleElements.cpp b/src/passes/RemoveUnusedModuleElements.cpp index ca0817b20..ec9753367 100644 --- a/src/passes/RemoveUnusedModuleElements.cpp +++ b/src/passes/RemoveUnusedModuleElements.cpp @@ -87,13 +87,13 @@ struct ReachabilityAnalyzer : public PostWalker<ReachabilityAnalyzer> { } void visitCallIndirect(CallIndirect* curr) { usesTable = true; } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { if (reachable.count(ModuleElement(ModuleElementKind::Global, curr->name)) == 0) { queue.emplace_back(ModuleElementKind::Global, curr->name); } } - void visitSetGlobal(SetGlobal* curr) { + void visitGlobalSet(GlobalSet* curr) { if (reachable.count(ModuleElement(ModuleElementKind::Global, curr->name)) == 0) { queue.emplace_back(ModuleElementKind::Global, curr->name); @@ -111,7 +111,7 @@ struct ReachabilityAnalyzer : public PostWalker<ReachabilityAnalyzer> { void visitMemoryCopy(MemoryCopy* curr) { usesMemory = true; } void visitMemoryFill(MemoryFill* curr) { usesMemory = true; } void visitHost(Host* curr) { - if (curr->op == CurrentMemory || curr->op == GrowMemory) { + if (curr->op == MemorySize || curr->op == MemoryGrow) { usesMemory = true; } } diff --git a/src/passes/ReorderLocals.cpp b/src/passes/ReorderLocals.cpp index e5e01af5d..3315d0e02 100644 --- a/src/passes/ReorderLocals.cpp +++ b/src/passes/ReorderLocals.cpp @@ -101,13 +101,13 @@ struct ReorderLocals : public WalkerPass<PostWalker<ReorderLocals>> { ReIndexer(Function* func, std::vector<Index>& oldToNew) : func(func), oldToNew(oldToNew) {} - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { if (func->isVar(curr->index)) { curr->index = oldToNew[curr->index]; } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (func->isVar(curr->index)) { curr->index = oldToNew[curr->index]; } @@ -129,14 +129,14 @@ struct ReorderLocals : public WalkerPass<PostWalker<ReorderLocals>> { } } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { counts[curr->index]++; if (firstUses.count(curr->index) == 0) { firstUses[curr->index] = firstUses.size(); } } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { counts[curr->index]++; if (firstUses.count(curr->index) == 0) { firstUses[curr->index] = firstUses.size(); diff --git a/src/passes/SSAify.cpp b/src/passes/SSAify.cpp index 990a627f6..bcafb2784 100644 --- a/src/passes/SSAify.cpp +++ b/src/passes/SSAify.cpp @@ -61,7 +61,7 @@ namespace wasm { // A set we know is impossible / not in the ast -static SetLocal IMPOSSIBLE_SET; +static LocalSet IMPOSSIBLE_SET; // Tracks assignments to locals, assuming single-assignment form, i.e., // each assignment creates a new variable. @@ -97,7 +97,7 @@ struct SSAify : public Pass { } void createNewIndexes(LocalGraph& graph) { - FindAll<SetLocal> sets(func->body); + FindAll<LocalSet> sets(func->body); for (auto* set : sets.list) { // Indexes already in SSA form do not need to be modified - there is // already just one set for that index. Otherwise, use a new index, unless @@ -108,7 +108,7 @@ struct SSAify : public Pass { } } - bool hasMerges(SetLocal* set, LocalGraph& graph) { + bool hasMerges(LocalSet* set, LocalGraph& graph) { for (auto* get : graph.setInfluences[set]) { if (graph.getSetses[get].size() > 1) { return true; @@ -118,7 +118,7 @@ struct SSAify : public Pass { } void computeGetsAndPhis(LocalGraph& graph) { - FindAll<GetLocal> gets(func->body); + FindAll<LocalGet> gets(func->body); for (auto* get : gets.list) { auto& sets = graph.getSetses[get]; if (sets.size() == 0) { @@ -154,7 +154,7 @@ struct SSAify : public Pass { if (set) { // a set exists, just add a tee of its value auto* value = set->value; - auto* tee = builder.makeTeeLocal(new_, value); + auto* tee = builder.makeLocalTee(new_, value); set->value = tee; // the value may have been something we tracked the location // of. if so, update that, since we moved it into the tee @@ -167,8 +167,8 @@ struct SSAify : public Pass { if (func->isParam(old)) { // we add a set with the proper // param value at the beginning of the function - auto* set = builder.makeSetLocal( - new_, builder.makeGetLocal(old, func->getLocalType(old))); + auto* set = builder.makeLocalSet( + new_, builder.makeLocalGet(old, func->getLocalType(old))); functionPrepends.push_back(set); } else { // this is a zero init, so we don't need to do anything actually diff --git a/src/passes/SafeHeap.cpp b/src/passes/SafeHeap.cpp index 2cc309a92..52b4580b5 100644 --- a/src/passes/SafeHeap.cpp +++ b/src/passes/SafeHeap.cpp @@ -243,10 +243,10 @@ struct SafeHeap : public Pass { func->result = style.type; Builder builder(*module); auto* block = builder.makeBlock(); - block->list.push_back(builder.makeSetLocal( + block->list.push_back(builder.makeLocalSet( 2, builder.makeBinary( - AddInt32, builder.makeGetLocal(0, i32), builder.makeGetLocal(1, i32)))); + AddInt32, builder.makeLocalGet(0, i32), builder.makeLocalGet(1, i32)))); // check for reading past valid memory: if pointer + offset + bytes block->list.push_back(makeBoundsCheck(style.type, builder, 2, style.bytes)); // check proper alignment @@ -256,7 +256,7 @@ struct SafeHeap : public Pass { // do the load auto* load = module->allocator.alloc<Load>(); *load = style; // basically the same as the template we are given! - load->ptr = builder.makeGetLocal(2, i32); + load->ptr = builder.makeLocalGet(2, i32); Expression* last = load; if (load->isAtomic && load->signed_) { // atomic loads cannot be signed, manually sign it @@ -284,10 +284,10 @@ struct SafeHeap : public Pass { func->result = none; Builder builder(*module); auto* block = builder.makeBlock(); - block->list.push_back(builder.makeSetLocal( + block->list.push_back(builder.makeLocalSet( 3, builder.makeBinary( - AddInt32, builder.makeGetLocal(0, i32), builder.makeGetLocal(1, i32)))); + AddInt32, builder.makeLocalGet(0, i32), builder.makeLocalGet(1, i32)))); // check for reading past valid memory: if pointer + offset + bytes block->list.push_back( makeBoundsCheck(style.valueType, builder, 3, style.bytes)); @@ -298,8 +298,8 @@ struct SafeHeap : public Pass { // do the store auto* store = module->allocator.alloc<Store>(); *store = style; // basically the same as the template we are given! - store->ptr = builder.makeGetLocal(3, i32); - store->value = builder.makeGetLocal(2, style.valueType); + store->ptr = builder.makeLocalGet(3, i32); + store->value = builder.makeLocalGet(2, style.valueType); block->list.push_back(store); block->finalize(none); func->body = block; @@ -309,7 +309,7 @@ struct SafeHeap : public Pass { Expression* makeAlignCheck(Address align, Builder& builder, Index local) { return builder.makeIf( builder.makeBinary(AndInt32, - builder.makeGetLocal(local, i32), + builder.makeLocalGet(local, i32), builder.makeConst(Literal(int32_t(align - 1)))), builder.makeCall(alignfault, {}, none)); } @@ -322,15 +322,15 @@ struct SafeHeap : public Pass { builder.makeBinary( OrInt32, builder.makeBinary(upperOp, - builder.makeGetLocal(local, i32), + builder.makeLocalGet(local, i32), builder.makeConst(Literal(int32_t(upperBound)))), builder.makeBinary( GtUInt32, builder.makeBinary(AddInt32, - builder.makeGetLocal(local, i32), + builder.makeLocalGet(local, i32), builder.makeConst(Literal(int32_t(bytes)))), builder.makeLoad( - 4, false, 0, 4, builder.makeGetGlobal(dynamicTopPtr, i32), i32))), + 4, false, 0, 4, builder.makeGlobalGet(dynamicTopPtr, i32), i32))), builder.makeCall(segfault, {}, none)); } }; diff --git a/src/passes/SimplifyGlobals.cpp b/src/passes/SimplifyGlobals.cpp index 12c59fefc..87891352d 100644 --- a/src/passes/SimplifyGlobals.cpp +++ b/src/passes/SimplifyGlobals.cpp @@ -47,7 +47,7 @@ struct GlobalUseScanner : public WalkerPass<PostWalker<GlobalUseScanner>> { GlobalUseScanner* create() override { return new GlobalUseScanner(infos); } - void visitSetGlobal(SetGlobal* curr) { (*infos)[curr->name].written = true; } + void visitGlobalSet(GlobalSet* curr) { (*infos)[curr->name].written = true; } private: GlobalInfoMap* infos; @@ -65,7 +65,7 @@ struct GlobalUseModifier : public WalkerPass<PostWalker<GlobalUseModifier>> { return new GlobalUseModifier(copiedParentMap); } - void visitGetGlobal(GetGlobal* curr) { + void visitGlobalGet(GlobalGet* curr) { auto iter = copiedParentMap->find(curr->name); if (iter != copiedParentMap->end()) { curr->name = iter->second; @@ -112,7 +112,7 @@ struct SimplifyGlobals : public Pass { for (auto& global : module->globals) { auto child = global->name; if (!global->mutable_ && !global->imported()) { - if (auto* get = global->init->dynCast<GetGlobal>()) { + if (auto* get = global->init->dynCast<GlobalGet>()) { auto parent = get->name; if (!module->getGlobal(get->name)->mutable_) { copiedParentMap[child] = parent; diff --git a/src/passes/SimplifyLocals.cpp b/src/passes/SimplifyLocals.cpp index 71fd74f43..6b76faed3 100644 --- a/src/passes/SimplifyLocals.cpp +++ b/src/passes/SimplifyLocals.cpp @@ -117,7 +117,7 @@ struct SimplifyLocals bool firstCycle; // local => # of local.gets for it - GetLocalCounter getCounter; + LocalGetCounter getCounter; static void doNoteNonLinear(SimplifyLocals<allowTee, allowStructure, allowNesting>* self, @@ -216,14 +216,14 @@ struct SimplifyLocals } } - void optimizeGetLocal(GetLocal* curr) { + void optimizeLocalGet(LocalGet* curr) { auto found = sinkables.find(curr->index); if (found != sinkables.end()) { auto* set = (*found->second.item) - ->template cast<SetLocal>(); // the set we may be sinking + ->template cast<LocalSet>(); // the set we may be sinking bool oneUse = firstCycle || getCounter.num[curr->index] == 1; // the set's value may be a get (i.e., the set is a copy) - auto* get = set->value->template dynCast<GetLocal>(); + auto* get = set->value->template dynCast<LocalGet>(); // if nesting is not allowed, and this might cause nesting, check if the // sink would cause such a thing if (!allowNesting) { @@ -232,7 +232,7 @@ struct SimplifyLocals assert(expressionStack.size() >= 2); assert(expressionStack[expressionStack.size() - 1] == curr); auto* parent = expressionStack[expressionStack.size() - 2]; - bool parentIsSet = parent->template is<SetLocal>(); + bool parentIsSet = parent->template is<LocalSet>(); // if the parent of this get is a set, we can sink into the set's // value, it would not be nested. if (!parentIsSet) { @@ -258,7 +258,7 @@ struct SimplifyLocals assert(!set->isTee()); set->setTee(true); } - // reuse the getlocal that is dying + // reuse the local.get that is dying *found->second.item = curr; ExpressionManipulator::nop(curr); sinkables.erase(found); @@ -268,7 +268,7 @@ struct SimplifyLocals void visitDrop(Drop* curr) { // collapse drop-tee into set, which can occur if a get was sunk into a tee - auto* set = curr->value->dynCast<SetLocal>(); + auto* set = curr->value->dynCast<LocalSet>(); if (set) { assert(set->isTee()); set->setTee(false); @@ -355,28 +355,28 @@ struct SimplifyLocals Expression* original = *currp; - GetLocal originalGet; + LocalGet originalGet; - if (auto* get = (*currp)->dynCast<GetLocal>()) { - // Note: no visitor for GetLocal, so that we can handle it here. + if (auto* get = (*currp)->dynCast<LocalGet>()) { + // Note: no visitor for LocalGet, so that we can handle it here. originalGet = *get; original = &originalGet; - self->optimizeGetLocal(get); + self->optimizeLocalGet(get); } - // perform main SetLocal processing here, since we may be the result of - // replaceCurrent, i.e., no visitor for SetLocal, like GetLocal above. - auto* set = (*currp)->dynCast<SetLocal>(); + // perform main LocalSet processing here, since we may be the result of + // replaceCurrent, i.e., no visitor for LocalSet, like LocalGet above. + auto* set = (*currp)->dynCast<LocalSet>(); if (set) { // if we see a set that was already potentially-sinkable, then the // previous store is dead, leave just the value auto found = self->sinkables.find(set->index); if (found != self->sinkables.end()) { - auto* previous = (*found->second.item)->template cast<SetLocal>(); + auto* previous = (*found->second.item)->template cast<LocalSet>(); assert(!previous->isTee()); auto* previousValue = previous->value; - Drop* drop = ExpressionManipulator::convert<SetLocal, Drop>(previous); + Drop* drop = ExpressionManipulator::convert<LocalSet, Drop>(previous); drop->value = previousValue; drop->finalize(); self->sinkables.erase(found); @@ -401,7 +401,7 @@ struct SimplifyLocals } } - bool canSink(SetLocal* set) { + bool canSink(LocalSet* set) { // we can never move a tee if (set->isTee()) { return false; @@ -438,7 +438,7 @@ struct SimplifyLocals } Builder builder(*this->getModule()); auto** item = sinkables.at(goodIndex).item; - auto* set = (*item)->template cast<SetLocal>(); + auto* set = (*item)->template cast<LocalSet>(); block->list[block->list.size() - 1] = set->value; *item = builder.makeNop(); block->finalize(); @@ -506,23 +506,23 @@ struct SimplifyLocals // so we must check for that. for (size_t j = 0; j < breaks.size(); j++) { // move break local.set's value to the break - auto* breakSetLocalPointer = breaks[j].sinkables.at(sharedIndex).item; + auto* breakLocalSetPointer = breaks[j].sinkables.at(sharedIndex).item; auto* brp = breaks[j].brp; auto* br = (*brp)->template cast<Break>(); - auto* set = (*breakSetLocalPointer)->template cast<SetLocal>(); + auto* set = (*breakLocalSetPointer)->template cast<LocalSet>(); if (br->condition) { // TODO: optimize - FindAll<SetLocal> findAll(br->condition); + FindAll<LocalSet> findAll(br->condition); for (auto* otherSet : findAll.list) { if (otherSet == set) { // the set is indeed in the condition, so we can't just move it // but maybe there are no effects? see if, ignoring the set // itself, there is any risk Nop nop; - *breakSetLocalPointer = &nop; + *breakLocalSetPointer = &nop; EffectAnalyzer condition(this->getPassOptions(), br->condition); EffectAnalyzer value(this->getPassOptions(), set); - *breakSetLocalPointer = set; + *breakLocalSetPointer = set; if (condition.invalidates(value)) { // indeed, we can't do this, stop return; @@ -543,24 +543,24 @@ struct SimplifyLocals } // move block local.set's value to the end, in return position, and nop the // set - auto* blockSetLocalPointer = sinkables.at(sharedIndex).item; - auto* value = (*blockSetLocalPointer)->template cast<SetLocal>()->value; + auto* blockLocalSetPointer = sinkables.at(sharedIndex).item; + auto* value = (*blockLocalSetPointer)->template cast<LocalSet>()->value; block->list[block->list.size() - 1] = value; block->type = value->type; - ExpressionManipulator::nop(*blockSetLocalPointer); + ExpressionManipulator::nop(*blockLocalSetPointer); for (size_t j = 0; j < breaks.size(); j++) { // move break local.set's value to the break - auto* breakSetLocalPointer = breaks[j].sinkables.at(sharedIndex).item; + auto* breakLocalSetPointer = breaks[j].sinkables.at(sharedIndex).item; auto* brp = breaks[j].brp; auto* br = (*brp)->template cast<Break>(); assert(!br->value); // if the break is conditional, then we must set the value here - if the // break is not reached, we must still have the new value in the local - auto* set = (*breakSetLocalPointer)->template cast<SetLocal>(); + auto* set = (*breakLocalSetPointer)->template cast<LocalSet>(); if (br->condition) { br->value = set; set->setTee(true); - *breakSetLocalPointer = + *breakLocalSetPointer = this->getModule()->allocator.template alloc<Nop>(); // in addition, as this is a conditional br that now has a value, it now // returns a value, so it must be dropped @@ -572,9 +572,9 @@ struct SimplifyLocals } } // finally, create a local.set on the block itself - auto* newSetLocal = - Builder(*this->getModule()).makeSetLocal(sharedIndex, block); - this->replaceCurrent(newSetLocal); + auto* newLocalSet = + Builder(*this->getModule()).makeLocalSet(sharedIndex, block); + this->replaceCurrent(newLocalSet); sinkables.clear(); anotherCycle = true; } @@ -657,7 +657,7 @@ struct SimplifyLocals if (iff->ifTrue->type != unreachable) { auto* ifTrueItem = ifTrue.at(goodIndex).item; ifTrueBlock->list[ifTrueBlock->list.size() - 1] = - (*ifTrueItem)->template cast<SetLocal>()->value; + (*ifTrueItem)->template cast<LocalSet>()->value; ExpressionManipulator::nop(*ifTrueItem); ifTrueBlock->finalize(); assert(ifTrueBlock->type != none); @@ -665,7 +665,7 @@ struct SimplifyLocals if (iff->ifFalse->type != unreachable) { auto* ifFalseItem = ifFalse.at(goodIndex).item; ifFalseBlock->list[ifFalseBlock->list.size() - 1] = - (*ifFalseItem)->template cast<SetLocal>()->value; + (*ifFalseItem)->template cast<LocalSet>()->value; ExpressionManipulator::nop(*ifFalseItem); ifFalseBlock->finalize(); assert(ifFalseBlock->type != none); @@ -673,9 +673,9 @@ struct SimplifyLocals iff->finalize(); // update type assert(iff->type != none); // finally, create a local.set on the iff itself - auto* newSetLocal = - Builder(*this->getModule()).makeSetLocal(goodIndex, iff); - *currp = newSetLocal; + auto* newLocalSet = + Builder(*this->getModule()).makeLocalSet(goodIndex, iff); + *currp = newLocalSet; anotherCycle = true; } @@ -722,13 +722,13 @@ struct SimplifyLocals // Update the ifTrue side. Builder builder(*this->getModule()); auto** item = sinkables.at(goodIndex).item; - auto* set = (*item)->template cast<SetLocal>(); + auto* set = (*item)->template cast<LocalSet>(); ifTrueBlock->list[ifTrueBlock->list.size() - 1] = set->value; *item = builder.makeNop(); ifTrueBlock->finalize(); assert(ifTrueBlock->type != none); // Update the ifFalse side. - iff->ifFalse = builder.makeGetLocal(set->index, set->value->type); + iff->ifFalse = builder.makeLocalGet(set->index, set->value->type); iff->finalize(); // update type // Update the get count. getCounter.num[set->index]++; @@ -895,7 +895,7 @@ struct SimplifyLocals // will inhibit us creating an if return value. struct EquivalentOptimizer : public LinearExecutionWalker<EquivalentOptimizer> { - std::vector<Index>* numGetLocals; + std::vector<Index>* numLocalGets; bool removeEquivalentSets; Module* module; @@ -911,13 +911,13 @@ struct SimplifyLocals self->equivalences.clear(); } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { // Remove trivial copies, even through a tee auto* value = curr->value; - while (auto* subSet = value->dynCast<SetLocal>()) { + while (auto* subSet = value->dynCast<LocalSet>()) { value = subSet->value; } - if (auto* get = value->dynCast<GetLocal>()) { + if (auto* get = value->dynCast<LocalGet>()) { if (equivalences.check(curr->index, get->index)) { // This is an unnecessary copy! if (removeEquivalentSets) { @@ -939,7 +939,7 @@ struct SimplifyLocals } } - void visitGetLocal(GetLocal* curr) { + void visitLocalGet(LocalGet* curr) { // Canonicalize gets: if some are equivalent, then we can pick more // then one, and other passes may benefit from having more uniformity. if (auto* set = equivalences.getEquivalents(curr->index)) { @@ -949,7 +949,7 @@ struct SimplifyLocals // get*, as we want to see what is best overall, treating this one as // to be decided upon. auto getNumGetsIgnoringCurr = [&](Index index) { - auto ret = (*numGetLocals)[index]; + auto ret = (*numLocalGets)[index]; if (index == curr->index) { assert(ret >= 1); ret--; @@ -969,9 +969,9 @@ struct SimplifyLocals if (best != curr->index && getNumGetsIgnoringCurr(best) > getNumGetsIgnoringCurr(curr->index)) { // Update the get counts. - (*numGetLocals)[best]++; - assert((*numGetLocals)[curr->index] >= 1); - (*numGetLocals)[curr->index]--; + (*numLocalGets)[best]++; + assert((*numLocalGets)[curr->index] >= 1); + (*numLocalGets)[curr->index]--; // Make the change. curr->index = best; anotherCycle = true; @@ -982,7 +982,7 @@ struct SimplifyLocals EquivalentOptimizer eqOpter; eqOpter.module = this->getModule(); - eqOpter.numGetLocals = &getCounter.num; + eqOpter.numLocalGets = &getCounter.num; eqOpter.removeEquivalentSets = allowStructure; eqOpter.walkFunction(func); diff --git a/src/passes/Souperify.cpp b/src/passes/Souperify.cpp index 6d7176e40..199db727e 100644 --- a/src/passes/Souperify.cpp +++ b/src/passes/Souperify.cpp @@ -79,9 +79,9 @@ struct UseFinder { } // There may be loops of sets with copies between them. - std::unordered_set<SetLocal*> seenSets; + std::unordered_set<LocalSet*> seenSets; - void addSetUses(SetLocal* set, + void addSetUses(LocalSet* set, Graph& graph, LocalGraph& localGraph, std::vector<Expression*>& ret) { @@ -261,7 +261,7 @@ struct Trace { break; } // Add the dependencies. - assert(!node->expr->is<GetLocal>()); + assert(!node->expr->is<LocalGet>()); for (Index i = 0; i < node->values.size(); i++) { add(node->getValue(i), depth); } diff --git a/src/passes/SpillPointers.cpp b/src/passes/SpillPointers.cpp index 6c194eb60..5c3d546ad 100644 --- a/src/passes/SpillPointers.cpp +++ b/src/passes/SpillPointers.cpp @@ -103,7 +103,7 @@ struct SpillPointers } // scan through the block, spilling around the calls // TODO: we can filter on pointerMap everywhere - LocalSet live = liveness.end; + SetOfLocals live = liveness.end; for (int i = int(actions.size()) - 1; i >= 0; i--) { auto& action = actions[i]; if (action.isGet()) { @@ -160,14 +160,14 @@ struct SpillPointers // move the operands into locals, as we must spill after they are executed auto handleOperand = [&](Expression*& operand) { auto temp = builder.addVar(func, operand->type); - auto* set = builder.makeSetLocal(temp, operand); + auto* set = builder.makeLocalSet(temp, operand); block->list.push_back(set); block->finalize(); if (actualPointers.count(&operand) > 0) { // this is something we track, and it's moving - update actualPointers[&operand] = &set->value; } - operand = builder.makeGetLocal(temp, operand->type); + operand = builder.makeLocalGet(temp, operand->type); }; if (call->is<Call>()) { for (auto*& operand : call->cast<Call>()->operands) { @@ -187,8 +187,8 @@ struct SpillPointers builder.makeStore(getTypeSize(ABI::PointerType), pointerMap[index], getTypeSize(ABI::PointerType), - builder.makeGetLocal(spillLocal, ABI::PointerType), - builder.makeGetLocal(index, ABI::PointerType), + builder.makeLocalGet(spillLocal, ABI::PointerType), + builder.makeLocalGet(index, ABI::PointerType), ABI::PointerType)); } // add the (modified) call diff --git a/src/passes/StackIR.cpp b/src/passes/StackIR.cpp index 1f182dbc3..d834655b9 100644 --- a/src/passes/StackIR.cpp +++ b/src/passes/StackIR.cpp @@ -132,7 +132,7 @@ private: localGraph.computeInfluences(); // We maintain a stack of relevant values. This contains: // * a null for each actual value that the value stack would have - // * an index of each SetLocal that *could* be on the value + // * an index of each LocalSet that *could* be on the value // stack at that location. const Index null = -1; std::vector<Index> values; @@ -188,7 +188,7 @@ private: // This is something we should handle, look into it. if (isConcreteType(inst->type)) { bool optimized = false; - if (auto* get = inst->origin->dynCast<GetLocal>()) { + if (auto* get = inst->origin->dynCast<LocalGet>()) { // This is a potential optimization opportunity! See if we // can reach the set. if (values.size() > 0) { @@ -199,7 +199,7 @@ private: if (index == null) { break; } - auto* set = insts[index]->origin->cast<SetLocal>(); + auto* set = insts[index]->origin->cast<LocalSet>(); if (set->index == get->index) { // This might be a proper set-get pair, where the set is // used by this get and nothing else, check that. @@ -238,7 +238,7 @@ private: // This is an actual regular value on the value stack. values.push_back(null); } - } else if (inst->origin->is<SetLocal>() && inst->type == none) { + } else if (inst->origin->is<LocalSet>() && inst->type == none) { // This set is potentially optimizable later, add to stack. values.push_back(i); } diff --git a/src/passes/TrapMode.cpp b/src/passes/TrapMode.cpp index b36427138..df900a125 100644 --- a/src/passes/TrapMode.cpp +++ b/src/passes/TrapMode.cpp @@ -103,7 +103,7 @@ Function* generateBinaryFunc(Module& wasm, Binary* curr) { bool isI64 = type == i64; Builder builder(wasm); Expression* result = builder.makeBinary( - op, builder.makeGetLocal(0, type), builder.makeGetLocal(1, type)); + op, builder.makeLocalGet(0, type), builder.makeLocalGet(1, type)); BinaryOp divSIntOp = isI64 ? DivSInt64 : DivSInt32; UnaryOp eqZOp = isI64 ? EqZInt64 : EqZInt32; Literal minLit = isI64 ? Literal(std::numeric_limits<int64_t>::min()) @@ -117,9 +117,9 @@ Function* generateBinaryFunc(Module& wasm, Binary* curr) { builder.makeBinary( AndInt32, builder.makeBinary( - eqOp, builder.makeGetLocal(0, type), builder.makeConst(minLit)), + eqOp, builder.makeLocalGet(0, type), builder.makeConst(minLit)), builder.makeBinary( - eqOp, builder.makeGetLocal(1, type), builder.makeConst(negLit))), + eqOp, builder.makeLocalGet(1, type), builder.makeConst(negLit))), builder.makeConst(zeroLit), result); } @@ -129,7 +129,7 @@ Function* generateBinaryFunc(Module& wasm, Binary* curr) { func->params.push_back(type); func->result = type; func->body = - builder.makeIf(builder.makeUnary(eqZOp, builder.makeGetLocal(1, type)), + builder.makeIf(builder.makeUnary(eqZOp, builder.makeLocalGet(1, type)), builder.makeConst(zeroLit), result); return func; @@ -190,25 +190,25 @@ Function* generateUnaryFunc(Module& wasm, Unary* curr) { func->name = getUnaryFuncName(curr); func->params.push_back(type); func->result = retType; - func->body = builder.makeUnary(truncOp, builder.makeGetLocal(0, type)); + func->body = builder.makeUnary(truncOp, builder.makeLocalGet(0, type)); // too small XXX this is different than asm.js, which does frem. here we // clamp, which is much simpler/faster, and similar to native builds func->body = builder.makeIf(builder.makeBinary(leOp, - builder.makeGetLocal(0, type), + builder.makeLocalGet(0, type), builder.makeConst(fMin)), builder.makeConst(iMin), func->body); // too big XXX see above func->body = builder.makeIf( builder.makeBinary( - geOp, builder.makeGetLocal(0, type), builder.makeConst(fMax)), + geOp, builder.makeLocalGet(0, type), builder.makeConst(fMax)), // NB: min here as well. anything out of range => to the min builder.makeConst(iMin), func->body); // nan func->body = builder.makeIf( builder.makeBinary( - neOp, builder.makeGetLocal(0, type), builder.makeGetLocal(0, type)), + neOp, builder.makeLocalGet(0, type), builder.makeLocalGet(0, type)), // NB: min here as well. anything invalid => to the min builder.makeConst(iMin), func->body); diff --git a/src/passes/Untee.cpp b/src/passes/Untee.cpp index 713962aeb..79c76b988 100644 --- a/src/passes/Untee.cpp +++ b/src/passes/Untee.cpp @@ -33,7 +33,7 @@ struct Untee : public WalkerPass<PostWalker<Untee>> { Pass* create() override { return new Untee; } - void visitSetLocal(SetLocal* curr) { + void visitLocalSet(LocalSet* curr) { if (curr->isTee()) { if (curr->value->type == unreachable) { // we don't reach the tee, just remove it @@ -42,7 +42,7 @@ struct Untee : public WalkerPass<PostWalker<Untee>> { // a normal tee. replace with set and get Builder builder(*getModule()); replaceCurrent(builder.makeSequence( - curr, builder.makeGetLocal(curr->index, curr->value->type))); + curr, builder.makeLocalGet(curr->index, curr->value->type))); curr->setTee(false); } } diff --git a/src/passes/Vacuum.cpp b/src/passes/Vacuum.cpp index 0e01c0370..82d904701 100644 --- a/src/passes/Vacuum.cpp +++ b/src/passes/Vacuum.cpp @@ -84,10 +84,10 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> { case Expression::Id::SwitchId: case Expression::Id::CallId: case Expression::Id::CallIndirectId: - case Expression::Id::SetLocalId: + case Expression::Id::LocalSetId: case Expression::Id::StoreId: case Expression::Id::ReturnId: - case Expression::Id::SetGlobalId: + case Expression::Id::GlobalSetId: case Expression::Id::HostId: case Expression::Id::UnreachableId: return curr; // always needed @@ -106,8 +106,8 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> { return curr; } case Expression::Id::ConstId: - case Expression::Id::GetLocalId: - case Expression::Id::GetGlobalId: { + case Expression::Id::LocalGetId: + case Expression::Id::GlobalGetId: { if (!resultUsed) { return nullptr; } @@ -344,7 +344,7 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> { return; } // a drop of a tee is a set - if (auto* set = curr->value->dynCast<SetLocal>()) { + if (auto* set = curr->value->dynCast<LocalSet>()) { assert(set->isTee()); set->setTee(false); replaceCurrent(set); |