hphp/runtime/vm/jit/irlower-lookup-cls-func.cpp

   1
   2 /*
   3    +----------------------------------------------------------------------+
   4    | HipHop for PHP                                                       |
   5    +----------------------------------------------------------------------+
   6    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   7    +----------------------------------------------------------------------+
   8    | This source file is subject to version 3.01 of the PHP license,      |
   9    | that is bundled with this package in the file LICENSE, and is        |
  10    | available through the world-wide-web at the following url:           |
  11    | http://www.php.net/license/3_01.txt                                  |
  12    | If you did not receive a copy of the PHP license and are unable to   |
  13    | obtain it through the world-wide-web, please send a note to          |
  14    | license@php.net so we can mail you a copy immediately.               |
  15    +----------------------------------------------------------------------+
  16 */
  17
  18 #include "hphp/runtime/vm/jit/irlower-internal.h"
  19
  20 #include "hphp/runtime/base/autoload-handler.h"
  21 #include "hphp/runtime/base/builtin-functions.h"
  22 #include "hphp/runtime/base/object-data.h"
  23 #include "hphp/runtime/base/rds.h"
  24 #include "hphp/runtime/base/runtime-error.h"
  25 #include "hphp/runtime/base/string-data.h"
  26 #include "hphp/runtime/base/strings.h"
  27 #include "hphp/runtime/base/tv-mutate.h"
  28 #include "hphp/runtime/base/tv-variant.h"
  29 #include "hphp/runtime/base/type-string.h"
  30 #include "hphp/runtime/base/typed-value.h"
  31 #include "hphp/runtime/base/vanilla-vec.h"
  32
  33 #include "hphp/runtime/vm/act-rec.h"
  34 #include "hphp/runtime/vm/class.h"
  35 #include "hphp/runtime/vm/func.h"
  36 #include "hphp/runtime/vm/interp-helpers.h"
  37 #include "hphp/runtime/vm/method-lookup.h"
  38 #include "hphp/runtime/vm/named-entity.h"
  39 #include "hphp/runtime/vm/unit.h"
  40 #include "hphp/runtime/vm/unit-util.h"
  41 #include "hphp/runtime/vm/vm-regs.h"
  42
  43 #include "hphp/system/systemlib.h"
  44
  45 #include "hphp/runtime/vm/jit/types.h"
  46 #include "hphp/runtime/vm/jit/abi.h"
  47 #include "hphp/runtime/vm/jit/arg-group.h"
  48 #include "hphp/runtime/vm/jit/bc-marker.h"
  49 #include "hphp/runtime/vm/jit/call-spec.h"
  50 #include "hphp/runtime/vm/jit/code-gen-cf.h"
  51 #include "hphp/runtime/vm/jit/code-gen-helpers.h"
  52 #include "hphp/runtime/vm/jit/extra-data.h"
  53 #include "hphp/runtime/vm/jit/ir-instruction.h"
  54 #include "hphp/runtime/vm/jit/ir-opcode.h"
  55 #include "hphp/runtime/vm/jit/ssa-tmp.h"
  56 #include "hphp/runtime/vm/jit/target-cache.h"
  57 #include "hphp/runtime/vm/jit/translator-inline.h"
  58 #include "hphp/runtime/vm/jit/translator-runtime.h"
  59 #include "hphp/runtime/vm/jit/type.h"
  60 #include "hphp/runtime/vm/jit/vasm-gen.h"
  61 #include "hphp/runtime/vm/jit/vasm-instr.h"
  62 #include "hphp/runtime/vm/jit/vasm-reg.h"
  63
  64 #include "hphp/util/asm-x64.h"
  65 #include "hphp/util/trace.h"
  66
  67 #include <type_traits>
  68
  69 namespace HPHP::jit::irlower {
  70
  71 TRACE_SET_MOD(irlower);
  72
  73 ///////////////////////////////////////////////////////////////////////////////
  74
  75 namespace {
  76
  77 template<class TargetCache>
  78 void implLdMeta(IRLS& env, const IRInstruction* inst, Vout& v, Vreg dst) {
  79   auto const is_func = std::is_same<TargetCache,FuncCache>::value;
  80
  81   auto const ch = TargetCache::alloc();
  82   rds::recordRds(ch, sizeof(TargetCache), is_func ? "FuncCache" : "ClassCache",
  83                  inst->marker().func()->fullName()->slice());
  84
  85   auto args = argGroup(env, inst).imm(ch).ssa(0 /* name */);
  86   cgCallHelper(
  87     v,
  88     env,
  89     CallSpec::direct(TargetCache::lookup),
  90     callDest(dst),
  91     SyncOptions::Sync,
  92     args
  93   );
  94 }
  95
  96 const Func* loadUnknownFuncHelper(const StringData* name,
  97                                   void (*raiser)(const StringData*,
  98                                                  const Class*)) {
  99   VMRegAnchor _;
 100   CoeffectsAutoGuard _2;
 101   auto const func = Func::load(name);
 102   if (UNLIKELY(!func)) raiser(name, nullptr);
 103   return func;
 104 }
 105
 106 const Class* lookupCls(const StringData* sd) {
 107   return Class::lookup(sd);
 108 }
 109
 110 void implLdOrLookupCls(IRLS& env, const IRInstruction* inst, bool lookup) {
 111   auto const src = srcLoc(env, inst, 0).reg();
 112   auto const dst = dstLoc(env, inst, 0).reg();
 113
 114   auto const fallback = [&](Vout& v, Vreg out) {
 115     if (!lookup) return implLdMeta<ClassCache>(env, inst, v, out);
 116     auto const args = argGroup(env, inst).ssa(0);
 117     cgCallHelper(v, env, CallSpec::direct(lookupCls),
 118                  callDest(out), SyncOptions::None, args);
 119   };
 120
 121   if (!RO::RepoAuthoritative) return fallback(vmain(env), dst);
 122
 123   auto& v = vmain(env);
 124   auto& vc = vcold(env);
 125   auto done = v.makeBlock();
 126   auto then = vc.makeBlock();
 127
 128   auto const sf1 = v.makeReg();
 129   auto const sf2 = v.makeReg();
 130   auto const cls1 = v.makeReg();
 131   auto const cls2 = v.makeReg();
 132
 133   auto const mask = static_cast<int8_t>(StringData::kIsSymbolMask);
 134   v << testbim{mask, src[StringData::isSymbolOffset()], sf1};
 135   fwdJcc(v, env, CC_E, sf1, then);
 136   if (use_lowptr) {
 137     auto const low = v.makeReg();
 138     v << loadl{src[StringData::cachedClassOffset()], low};
 139     v << testl{low, low, sf2};
 140     fwdJcc(v, env, CC_E, sf2, then);
 141     v << movzlq{low, cls1};
 142   } else {
 143     v << load{src[StringData::cachedClassOffset()], cls1};
 144     v << testq{cls1, cls1, sf2};
 145     fwdJcc(v, env, CC_E, sf2, then);
 146   }
 147   v << phijmp{done, v.makeTuple({cls1})};
 148
 149   vc = then;
 150   fallback(vc, cls2);
 151   vc << phijmp{done, vc.makeTuple({cls2})};
 152
 153   v = done;
 154   v << phidef{v.makeTuple({dst})};
 155 }
 156
 157 }
 158
 159 void cgLdCls(IRLS& env, const IRInstruction* inst) {
 160   implLdOrLookupCls(env, inst, false);
 161 }
 162
 163 void cgLookupClsRDS(IRLS& env, const IRInstruction* inst) {
 164   implLdOrLookupCls(env, inst, true);
 165 }
 166
 167 void cgLdFunc(IRLS& env, const IRInstruction* inst) {
 168   auto const dst = dstLoc(env, inst, 0).reg();
 169   implLdMeta<FuncCache>(env, inst, vmain(env), dst);
 170 }
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173
 174 const Class* autoloadKnownPersistentType(rds::Handle h,
 175                                          const StringData* name) {
 176   assertx(rds::isPersistentHandle(h));
 177   AutoloadHandler::s_instance->autoloadType(
 178     StrNR(const_cast<StringData*>(name))
 179   );
 180   auto const ptr =
 181     rds::handleToRef<LowPtr<Class>, rds::Mode::Persistent>(h).get();
 182   // Autoloader should have inited it as a side-effect.
 183   if (UNLIKELY(!ptr)) raise_error(Strings::UNKNOWN_CLASS, name->data());
 184   return ptr;
 185 }
 186
 187 const Class* lookupKnownType(rds::Handle cache_handle,
 188                              const StringData* name) {
 189   assertx(rds::isNormalHandle(cache_handle));
 190   // The caller should already have checked.
 191   assertx(!rds::isHandleInit(cache_handle));
 192
 193   AutoloadHandler::s_instance->autoloadType(
 194     StrNR(const_cast<StringData*>(name))
 195   );
 196
 197   // Autoloader should have inited it as a side-effect.
 198   if (UNLIKELY(!rds::isHandleInit(cache_handle, rds::NormalTag{}))) {
 199     raise_error(Strings::UNKNOWN_CLASS, name->data());
 200   }
 201   return rds::handleToRef<LowPtr<Class>, rds::Mode::Normal>(cache_handle).get();
 202 }
 203
 204 const Func* loadUnknownFunc(const StringData* name) {
 205   return loadUnknownFuncHelper(name, raise_call_to_undefined);
 206 }
 207
 208 const Func* lookupUnknownFunc(const StringData* name) {
 209   return loadUnknownFuncHelper(name, raise_resolve_undefined);
 210 }
 211
 212 ///////////////////////////////////////////////////////////////////////////////
 213
 214 namespace {
 215
 216 template<class T> rds::Handle handleFrom(
 217   const NamedEntity* ne,
 218   const StringData* name
 219 );
 220
 221 template<>
 222 rds::Handle handleFrom<Func>(const NamedEntity* ne,
 223                              const StringData* name) {
 224   return ne->getFuncHandle(name);
 225 }
 226 template<>
 227 rds::Handle handleFrom<Class>(const NamedEntity* ne,
 228                               const StringData* name) {
 229   return ne->getClassHandle(name);
 230 }
 231
 232 template<class T, class SlowPath>
 233 void implLdCached(IRLS& env, const IRInstruction* inst,
 234                   const StringData* name, SlowPath fill_cache) {
 235   auto const dst = dstLoc(env, inst, 0).reg();
 236   auto const ch = handleFrom<T>(NamedEntity::get(name), name);
 237   auto& v = vmain(env);
 238
 239   if (rds::isNormalHandle(ch)) {
 240     auto const sf = checkRDSHandleInitialized(v, ch);
 241     unlikelyCond(
 242       v, vcold(env), CC_NE, sf, dst,
 243       [&] (Vout& v) { return fill_cache(v, ch); },
 244       [&] (Vout& v) {
 245         markRDSAccess(v, ch);
 246         auto const ptr = v.makeReg();
 247         emitLdLowPtr(v, rvmtl()[ch], ptr, sizeof(LowPtr<T>));
 248         return ptr;
 249       }
 250     );
 251   } else {
 252     auto const pptr = rds::handleToPtr<LowPtr<T>, rds::Mode::Persistent>(ch);
 253     markRDSAccess(v, ch);
 254     auto const ptr = v.makeReg();
 255     emitLdLowPtr(v, *v.cns(pptr), ptr, sizeof(LowPtr<T>));
 256
 257     auto const sf = v.makeReg();
 258     v << testq{ptr, ptr, sf};
 259     unlikelyCond(v, vcold(env), CC_Z, sf, dst,
 260                  [&](Vout& v) { return fill_cache(v, ch); },
 261                  [&](Vout& /*v*/) { return ptr; });
 262   }
 263 }
 264
 265 template<Opcode opc>
 266 void ldFuncCachedHelper(IRLS& env, const IRInstruction* inst,
 267                         const CallSpec& call) {
 268   auto const extra = inst->extra<opc>();
 269
 270   implLdCached<Func>(env, inst, extra->name, [&] (Vout& v, rds::Handle) {
 271     auto const ptr = v.makeReg();
 272     auto const args = argGroup(env, inst).immPtr(extra->name);
 273     cgCallHelper(v, env, call, callDest(ptr), SyncOptions::Sync, args);
 274     return ptr;
 275   });
 276 }
 277
 278 }
 279
 280 ///////////////////////////////////////////////////////////////////////////////
 281
 282 void cgLdClsCached(IRLS& env, const IRInstruction* inst) {
 283   auto const name = inst->src(0)->strVal();
 284
 285   implLdCached<Class>(env, inst, name, [&] (Vout& v, rds::Handle ch) {
 286     auto const ptr = v.makeReg();
 287     auto const target = rds::isPersistentHandle(ch)
 288                         ? autoloadKnownPersistentType
 289                         : lookupKnownType;
 290     auto const args = argGroup(env, inst).imm(ch).ssa(0);
 291     cgCallHelper(v, env, CallSpec::direct(target),
 292                  callDest(ptr), SyncOptions::Sync, args);
 293     return ptr;
 294   });
 295 }
 296
 297 void cgLdFuncCached(IRLS& env, const IRInstruction* inst) {
 298   ldFuncCachedHelper<LdFuncCached>(
 299     env, inst, CallSpec::direct(loadUnknownFunc)
 300   );
 301 }
 302
 303 void cgLookupFuncCached(IRLS& env, const IRInstruction* inst) {
 304   ldFuncCachedHelper<LookupFuncCached>(
 305     env, inst, CallSpec::direct(lookupUnknownFunc)
 306   );
 307 }
 308
 309 void cgLdClsCachedSafe(IRLS& env, const IRInstruction* inst) {
 310   auto const name = inst->src(0)->strVal();
 311   auto const dst = dstLoc(env, inst, 0).reg();
 312   auto const ch = handleFrom<Class>(NamedEntity::get(name), name);
 313   auto& v = vmain(env);
 314
 315   if (rds::isNormalHandle(ch)) {
 316     auto const sf = checkRDSHandleInitialized(v, ch);
 317     fwdJcc(v, env, CC_NE, sf, inst->taken());
 318     markRDSAccess(v, ch);
 319     emitLdLowPtr(v, rvmtl()[ch], dst, sizeof(LowPtr<Class>));
 320   } else {
 321     assertx(rds::isPersistentHandle(ch));
 322     auto const pptr =
 323       rds::handleToPtr<LowPtr<Class>, rds::Mode::Persistent>(ch);
 324     markRDSAccess(v, ch);
 325     emitLdLowPtr(v, *v.cns(pptr), dst, sizeof(LowPtr<Class>));
 326   }
 327 }
 328
 329 ///////////////////////////////////////////////////////////////////////////////
 330
 331 IMPL_OPCODE_CALL(OODeclExists)
 332
 333 ///////////////////////////////////////////////////////////////////////////////
 334
 335 }