Method sideEffects

libyul/optimiser/Semantics.cpp:120–172

}

std::map<FunctionHandle, SideEffects> SideEffectsPropagator::sideEffects(
	Dialect const& _dialect,
	CallGraph const& _directCallGraph
)
{
	// Any loop currently makes a function non-movable, because
	// it could be a non-terminating loop.
	// The same is true for any function part of a call cycle.
	// In the future, we should refine that, because the property
	// is actually a bit different from "not movable".

	std::map<FunctionHandle, SideEffects> ret;
	for (auto const& function: _directCallGraph.functionsWithLoops)
	{
		ret[function].movable = false;
		ret[function].canBeRemoved = false;
		ret[function].canBeRemovedIfNoMSize = false;
		ret[function].cannotLoop = false;
	}

	for (auto const& function: _directCallGraph.recursiveFunctions())
	{
		ret[function].movable = false;
		ret[function].canBeRemoved = false;
		ret[function].canBeRemovedIfNoMSize = false;
		ret[function].cannotLoop = false;
	}

	for (auto const& call: _directCallGraph.functionCalls)
	{
		FunctionHandle funName = call.first;
		SideEffects sideEffects;
		auto _visit = [&, visited = std::set<FunctionHandle>{}](FunctionHandle _function, auto&& _recurse) mutable {
			if (!visited.insert(_function).second)
				return;
			if (sideEffects == SideEffects::worst())
				return;
			if (BuiltinHandle const* builtinHandle = std::get_if<BuiltinHandle>(&_function))
				sideEffects += _dialect.builtin(*builtinHandle).sideEffects;
			else
			{
				if (ret.count(_function))
					sideEffects += ret[_function];
				for (FunctionHandle const& callee: _directCallGraph.functionCalls.at(_function))
					_recurse(callee, _recurse);
			}
		};
		for (auto const& _v: call.second)
			_visit(_v, _visit);
		ret[funName] += sideEffects;
	}
	return ret;
}

MovableChecker::MovableChecker(Dialect const& _dialect, Expression const& _expression):
	MovableChecker(_dialect)