diff --git a/hphp/runtime/vm/translator/annotation.cpp b/hphp/runtime/vm/translator/annotation.cpp index 9533d65d4..599171681 100644 --- a/hphp/runtime/vm/translator/annotation.cpp +++ b/hphp/runtime/vm/translator/annotation.cpp @@ -100,7 +100,7 @@ static void recordActRecPush(NormalizedInstruction& i, fcall.m_offset = fpi->m_fcallOff; assert(isFCallStar(*unit->at(fcall.offset()))); if (clsName) { - const Class* cls = Unit::lookupClass(clsName); + const Class* cls = Unit::lookupUniqueClass(clsName); bool magic = false; const Func* func = lookupImmutableMethod(cls, name, magic, staticCall); if (func) { diff --git a/hphp/runtime/vm/translator/hopt/hhbctranslator.cpp b/hphp/runtime/vm/translator/hopt/hhbctranslator.cpp index 1a317a998..0dc899e6f 100644 --- a/hphp/runtime/vm/translator/hopt/hhbctranslator.cpp +++ b/hphp/runtime/vm/translator/hopt/hhbctranslator.cpp @@ -1417,7 +1417,7 @@ void HhbcTranslator::emitFPushClsMethodD(int32_t numParams, UNUSED const StringData* className = np.first; TRACE(3, "%u: FPushClsMethodD %s::%s %d\n", m_bcOff, className->data(), methodName->data(), numParams); - const Class* baseClass = Unit::lookupClass(np.second); + const Class* baseClass = Unit::lookupUniqueClass(np.second); bool magicCall = false; const Func* func = HPHP::VM::Transl::lookupImmutableMethod(baseClass, methodName, @@ -1944,7 +1944,8 @@ void HhbcTranslator::emitVerifyParamType(int32_t paramId, assert(!constraintClsName || constraintClsName->isStatic()); const Func* func = getCurFunc(); const Class* constraint = (constraintClsName ? - Unit::lookupClass(constraintClsName) : nullptr); + Unit::lookupUniqueClass(constraintClsName) : + nullptr); const TypeConstraint& tc = func->params()[paramId].typeConstraint(); const StringData* tcTypeName = tc.typeName(); @@ -2003,7 +2004,7 @@ void HhbcTranslator::emitInstanceOfD(int classNameStrId) { Class::initInstanceBits(); const bool haveBit = Class::haveInstanceBit(className); - Class* const maybeCls = Unit::lookupClass(className); + Class* const maybeCls = Unit::lookupUniqueClass(className); const bool isNormalClass = maybeCls && !(maybeCls->attrs() & (AttrTrait | AttrInterface)); diff --git a/hphp/runtime/vm/translator/hopt/simplifier.cpp b/hphp/runtime/vm/translator/hopt/simplifier.cpp index f69256ba5..999d5a706 100644 --- a/hphp/runtime/vm/translator/hopt/simplifier.cpp +++ b/hphp/runtime/vm/translator/hopt/simplifier.cpp @@ -267,7 +267,7 @@ SSATmp* Simplifier::simplifyGetCtxFwdCall(IRInstruction* inst) { SSATmp* Simplifier::simplifyLdCls(IRInstruction* inst) { SSATmp* clsName = inst->getSrc(0); if (clsName->isConst()) { - const Class* cls = Unit::lookupClass(clsName->getValStr()); + const Class* cls = Unit::lookupUniqueClass(clsName->getValStr()); if (cls) { if (RuntimeOption::RepoAuthoritative && (cls->attrs() & AttrUnique)) { // the class is unique diff --git a/hphp/runtime/vm/translator/translator-x64.cpp b/hphp/runtime/vm/translator/translator-x64.cpp index 1f82ae8ab..5cb9e60a2 100644 --- a/hphp/runtime/vm/translator/translator-x64.cpp +++ b/hphp/runtime/vm/translator/translator-x64.cpp @@ -7035,7 +7035,7 @@ TranslatorX64::emitKnownClassCheck(const NormalizedInstruction& i, RegNumber reg) { using namespace TargetCache; assert(clsName); - Class* klass = Unit::lookupClass(clsName); + Class* klass = Unit::lookupUniqueClass(clsName); bool guarded = false; if (klass) { guarded = i.guardedCls; @@ -8778,7 +8778,7 @@ TranslatorX64::translateFPushClsMethodD(const Tracelet& t, cls && cls->isStatic()); assert(i.inputs.size() == 0); - const Class* baseClass = Unit::lookupClass(np.second); + const Class* baseClass = Unit::lookupUniqueClass(np.second); bool magicCall = false; const Func* func = lookupImmutableMethod(baseClass, meth, magicCall, true /* staticLookup */); @@ -9160,7 +9160,7 @@ void TranslatorX64::translateFPushCtorD(const Tracelet& t, using namespace TargetCache; int numArgs = i.imm[0].u_IVA; const StringData* clsName = curUnit()->lookupLitstrId(i.imm[1].u_SA); - Class* cls = Unit::lookupClass(clsName); + Class* cls = Unit::lookupUniqueClass(clsName); bool fastPath = !RuntimeOption::EnableObjDestructCall && classIsPersistent(cls) && !(cls->attrs() & (AttrAbstract | AttrInterface | AttrTrait)) && @@ -9574,7 +9574,7 @@ TranslatorX64::findCuf(const NormalizedInstruction& ni, } else if (sclass->isame(s_static.get())) { return nullptr; } else { - cls = VM::Unit::lookupClass(sclass); + cls = VM::Unit::lookupUniqueClass(sclass); if (!cls) return nullptr; } @@ -10274,7 +10274,7 @@ TranslatorX64::translateVerifyParamType(const Tracelet& t, const StringData* clsName; if (!isSelfOrParent) { clsName = tc.typeName(); - constraint = Unit::lookupClass(clsName); + constraint = Unit::lookupUniqueClass(clsName); } else { if (tc.isSelf()) { tc.selfToClass(curFunc(), &constraint); @@ -10428,7 +10428,7 @@ TranslatorX64::translateInstanceOfD(const Tracelet& t, } const StringData* clsName = curUnit()->lookupLitstrId(i.imm[0].u_SA); - Class* maybeCls = Unit::lookupClass(clsName); + Class* maybeCls = Unit::lookupUniqueClass(clsName); // maybeInterface is just used as a hint: If it's a trait/interface now but // a class at runtime, InstanceOfDSlowInterface will still do the right diff --git a/hphp/runtime/vm/translator/translator.cpp b/hphp/runtime/vm/translator/translator.cpp index 0c754f330..e6aa2f34d 100644 --- a/hphp/runtime/vm/translator/translator.cpp +++ b/hphp/runtime/vm/translator/translator.cpp @@ -681,7 +681,7 @@ getDynLocType(const vector& inputs, if ((op == OpAGetC && inputs[0]->isString())) { const StringData *sd = inputs[0]->rtt.valueString(); if (sd) { - Class *klass = Unit::lookupClass(sd); + Class *klass = Unit::lookupUniqueClass(sd); TRACE(3, "KindOfClass: derived class \"%s\" from string literal\n", klass ? klass->preClass()->name()->data() : "NULL"); return RuntimeType(klass); @@ -1350,7 +1350,7 @@ void Translator::analyzeSecondPass(Tracelet& t) { /* new obj with a ctor that takes no args */ const NamedEntityPair& np = curUnit()->lookupNamedEntityPairId(prev->imm[1].u_SA); - const Class* cls = Unit::lookupClass(np.second); + const Class* cls = Unit::lookupUniqueClass(np.second); if (cls && (cls->attrs() & AttrUnique) && Func::isSpecial(cls->getCtor()->name())) { /* its the generated 86ctor, so no need to call it */ @@ -1719,8 +1719,8 @@ bool Translator::applyInputMetaData(Unit::MetaHandle& metaHand, dl->rtt.valueClass() ? dl->rtt.valueClass()->name() : nullptr; // The two classes might not be exactly the same, which is ok // as long as metaCls is more derived than rttCls. - Class* metaCls = Unit::lookupClass(metaName); - Class* rttCls = rttName ? Unit::lookupClass(rttName) : nullptr; + Class* metaCls = Unit::lookupUniqueClass(metaName); + Class* rttCls = rttName ? Unit::lookupUniqueClass(rttName) : nullptr; if (metaCls && rttCls && metaCls != rttCls && !metaCls->classof(rttCls)) { // Runtime type is more derived @@ -1741,7 +1741,7 @@ bool Translator::applyInputMetaData(Unit::MetaHandle& metaHand, case Unit::MetaInfo::MVecPropClass: { const StringData* metaName = ni->unit()->lookupLitstrId(info.m_data); - Class* metaCls = Unit::lookupClass(metaName); + Class* metaCls = Unit::lookupUniqueClass(metaName); if (metaCls) { ni->immVecClasses[arg] = metaCls; } diff --git a/hphp/runtime/vm/unit.h b/hphp/runtime/vm/unit.h index 3c59e4354..8dcb5d923 100644 --- a/hphp/runtime/vm/unit.h +++ b/hphp/runtime/vm/unit.h @@ -502,6 +502,10 @@ struct Unit { return cls; } + static Class *lookupUniqueClass(const StringData *clsName) { + return lookupUniqueClass(GetNamedEntity(clsName)); + } + static Class *lookupClass(const StringData *clsName) { Class *cls = *GetNamedEntity(clsName)->clsList(); if (LIKELY(cls != nullptr)) cls = cls->getCached();