/** @return Whether inlining will lower cost. */
private boolean doesLowerCost(
Node fnNode,
int callCost,
int directInlines,
int costDeltaDirect,
int blockInlines,
int costDeltaBlock,
boolean removable) {
// Determine the threshold value for this inequality:
// inline_cost < call_cost
// But solve it for the function declaration size so the size of it
// is only calculated once and terminated early if possible.
int fnInstanceCount = directInlines + blockInlines - (removable ? 1 : 0);
// Prevent division by zero.
if (fnInstanceCount == 0) {
// Special case single reference function that are being block inlined:
// If the cost of the inline is greater than the function definition size,
// don't inline.
if (blockInlines > 0 && costDeltaBlock > 0) {
return false;
}
return true;
}
int costDelta = (directInlines * costDeltaDirect) + (blockInlines * costDeltaBlock);
int threshold = (callCost - costDelta) / fnInstanceCount;
return InlineCostEstimator.getCost(fnNode, threshold + 1) <= threshold;
}
/** Calculates the minimum number of occurrences of throw needed to alias throw. */
static int estimateMinOccurrencesRequriedToAlias() {
// Assuming that the alias function name is two bytes in length, two bytes
// will be saved per occurrence of throw:
// <code>throw e;</code>, compared to
// <code>TT(e);</code>.
// However, the alias definition is some length, N, e.g.,
// <code>function TT(t){throw t;}</code>
// Hence there must be more than N/2 occurrences of throw to reduce
// the code size.
Node alias = createAliasFunctionNode("TT");
return InlineCostEstimator.getCost(alias) / 2 + 1;
}