Use lookupUniqueClass

The translator does better in a number of places when it
knows an AttrUnqiue Class* at translation time - even if it
doesnt know for sure that it will be defined when we enter the
tracelet. Now that we autoload (nearly) everything, we enter
a lot of tracelets where an AttrUnique Class* has been seen
(during warmup) but is not yet defined (in this request).
I added lookupUniqueClass while working on the new autoloader
to find such Classes, and allow us to do a better translation,
but never got around to using it.

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) {

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));

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

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

hphp/runtime/vm/translator/translator.cpp

@@ -681,7 +681,7 @@ getDynLocType(const vector<DynLocation*>& 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;
         }

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();