bool InliningDecider::canInlineAt(SrcKey callSK, const Func* callee) const {
if (!callee ||
!RuntimeOption::EvalHHIREnableGenTimeInlining ||
RuntimeOption::EvalJitEnableRenameFunction ||
callee->attrs() & AttrInterceptable) {
return false;
}
if (callee->cls()) {
if (!classHasPersistentRDS(callee->cls())) {
// if the callee's class is not persistent, its still ok
// to use it if we're jitting into a method of a subclass
auto ctx = callSK.func()->cls();
if (!ctx || !ctx->classof(callee->cls())) {
return false;
}
}
} else {
auto const handle = callee->funcHandle();
if (handle == rds::kInvalidHandle || !rds::isPersistentHandle(handle)) {
// if the callee isn't persistent, its still ok to
// use it if its defined at the top level in the same
// unit as the caller
if (callee->unit() != callSK.unit() || !callee->top()) {
return false;
}
}
}
// If inlining was disabled... don't inline.
if (m_disabled) return false;
// TODO(#3331014): We have this hack until more ARM codegen is working.
if (arch() == Arch::ARM) return false;
// We can only inline at normal FCalls.
if (callSK.op() != Op::FCall &&
callSK.op() != Op::FCallD) {
return false;
}
// Don't inline from resumed functions. The inlining mechanism doesn't have
// support for these---it has no way to redefine stack pointers relative to
// the frame pointer, because in a resumed function the frame pointer points
// into the heap instead of into the eval stack.
if (callSK.resumed()) return false;
// TODO(#4238160): Inlining into pseudomain callsites is still buggy.
if (callSK.func()->isPseudoMain()) return false;
if (!isCalleeInlinable(callSK, callee) || !checkNumArgs(callSK, callee)) {
return false;
}
return true;
}
void inlSingletonSProp(IRGS& env,
const Func* func,
const Op* clsOp,
const Op* propOp) {
assertx(*clsOp == Op::String);
assertx(*propOp == Op::String);
TransFlags trflags;
trflags.noinlineSingleton = true;
auto exitBlock = makeExit(env, trflags);
// Pull the class and property names.
auto const unit = func->unit();
auto const clsName = unit->lookupLitstrId(getImmPtr(clsOp, 0)->u_SA);
auto const propName = unit->lookupLitstrId(getImmPtr(propOp, 0)->u_SA);
// Make sure we have a valid class.
auto const cls = Unit::lookupClass(clsName);
if (UNLIKELY(!classHasPersistentRDS(cls))) {
PUNT(SingletonSProp-Persistent);
}
// Make sure the sprop is accessible from the singleton method's context.
auto const lookup = cls->findSProp(func->cls(), propName);
if (UNLIKELY(lookup.prop == kInvalidSlot || !lookup.accessible)) {
PUNT(SingletonSProp-Accessibility);
}
// Look up the static property.
auto const sprop = ldClsPropAddrKnown(env, cls, propName);
auto const unboxed = gen(env, UnboxPtr, sprop);
auto const value = gen(env, LdMem, unboxed->type().deref(), unboxed);
// Side exit if the static property is null.
auto isnull = gen(env, IsType, TNull, value);
gen(env, JmpNZero, exitBlock, isnull);
// Return the singleton.
pushIncRef(env, value);
}
