hphp/runtime/vm/class-inl.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_VM_CLASS_INL_H_
  18 #error "class-inl.h should only be included by class.h"
  19 #endif
  20
  21 #include "hphp/runtime/base/runtime-error.h"
  22 #include "hphp/runtime/base/strings.h"
  23
  24 namespace HPHP {
  25 ///////////////////////////////////////////////////////////////////////////////
  26
  27 inline bool Class::isZombie() const {
  28   return !m_cachedClass.bound();
  29 }
  30
  31
  32 inline bool Class::validate() const {
  33 #ifndef NDEBUG
  34   assertx(m_magic == kMagic);
  35 #endif
  36   assertx(name()->checkSane());
  37   return true;
  38 }
  39
  40 ///////////////////////////////////////////////////////////////////////////////
  41 // Class::PropInitVec.
  42
  43 inline Class::PropInitVec::PropInitVec() : m_data(nullptr),
  44                                            m_size(0),
  45                                            m_capacity(0) {
  46 }
  47
  48 inline Class::PropInitVec::iterator Class::PropInitVec::begin() {
  49   return m_data;
  50 }
  51
  52 inline Class::PropInitVec::iterator Class::PropInitVec::end() {
  53   return m_data + m_size;
  54 }
  55
  56 inline size_t Class::PropInitVec::size() const {
  57   return m_size;
  58 }
  59
  60 inline TypedValueAux& Class::PropInitVec::operator[](size_t i) {
  61   assertx(i < m_size);
  62   return m_data[i];
  63 }
  64
  65 inline const TypedValueAux& Class::PropInitVec::operator[](size_t i) const {
  66   assertx(i < m_size);
  67   return m_data[i];
  68 }
  69
  70 inline bool Class::PropInitVec::reqAllocated() const {
  71   return m_capacity < 0;
  72 }
  73
  74 ///////////////////////////////////////////////////////////////////////////////
  75 // Pre- and post-allocations.
  76
  77 inline LowPtr<Func>* Class::funcVec() const {
  78   return reinterpret_cast<LowPtr<Func>*>(
  79     reinterpret_cast<uintptr_t>(this) -
  80     m_funcVecLen * sizeof(LowPtr<Func>)
  81   );
  82 }
  83
  84 inline void* Class::mallocPtr() const {
  85   return reinterpret_cast<void*>(
  86     reinterpret_cast<uintptr_t>(funcVec()) & ~(alignof(Class) - 1)
  87   );
  88 }
  89
  90 inline const void* Class::mallocEnd() const {
  91   return reinterpret_cast<const char*>(this)
  92          + Class::classVecOff()
  93          + classVecLen() * sizeof(*classVec());
  94 }
  95
  96 inline const LowPtr<Class>* Class::classVec() const {
  97   return m_classVec;
  98 }
  99
 100 inline Class::veclen_t Class::classVecLen() const {
 101   return m_classVecLen;
 102 }
 103
 104 ///////////////////////////////////////////////////////////////////////////////
 105 // Ancestry.
 106
 107 inline bool Class::classofNonIFace(const Class* cls) const {
 108   assertx(!(cls->attrs() & AttrInterface));
 109   if (m_classVecLen >= cls->m_classVecLen) {
 110     return (m_classVec[cls->m_classVecLen-1] == cls);
 111   }
 112   return false;
 113 }
 114
 115 inline bool Class::classof(const Class* cls) const {
 116   // If `cls' is an interface, we can simply check to see if cls is in
 117   // this->m_interfaces.  Otherwise, if `this' is not an interface, the
 118   // classVec check will determine whether it's an instance of cls (including
 119   // the case where this and cls are the same trait).  Otherwise, `this' is an
 120   // interface, and `cls' is not, so we need to return false.  But the classVec
 121   // check can never return true in that case (cls's classVec contains only
 122   // non-interfaces, while this->classVec is either empty, or contains
 123   // interfaces).
 124   if (UNLIKELY(cls->attrs() & AttrInterface)) {
 125     return this == cls ||
 126       m_interfaces.lookupDefault(cls->m_preClass->name(), nullptr) == cls;
 127   }
 128   return classofNonIFace(cls);
 129 }
 130
 131 inline bool Class::ifaceofDirect(const StringData* name) const {
 132   return m_interfaces.contains(name);
 133 }
 134
 135 ///////////////////////////////////////////////////////////////////////////////
 136 // Basic info.
 137
 138 inline const StringData* Class::name() const {
 139   return m_preClass->name();
 140 }
 141
 142 inline const PreClass* Class::preClass() const {
 143   return m_preClass.get();
 144 }
 145
 146 inline Class* Class::parent() const {
 147   return m_parent.get();
 148 }
 149
 150 inline StrNR Class::nameStr() const {
 151   return m_preClass->nameStr();
 152 }
 153
 154 inline StrNR Class::parentStr() const {
 155   return m_preClass->parentStr();
 156 }
 157
 158 inline Attr Class::attrs() const {
 159   assertx(Attr(m_attrCopy) == m_preClass->attrs());
 160   return Attr(m_attrCopy);
 161 }
 162
 163 inline bool Class::rtAttribute(RuntimeAttribute a) const {
 164   return m_RTAttrs & a;
 165 }
 166
 167 inline void Class::initRTAttributes(uint8_t a) {
 168   m_RTAttrs |= a;
 169 }
 170
 171 inline bool Class::isPersistent() const {
 172   return attrs() & AttrPersistent;
 173 }
 174
 175 inline bool Class::isDynamicallyConstructible() const {
 176   return attrs() & AttrDynamicallyConstructible;
 177 }
 178
 179 ///////////////////////////////////////////////////////////////////////////////
 180 // Magic methods.
 181
 182 inline const Func* Class::getCtor() const {
 183   return m_ctor;
 184 }
 185
 186 inline const Func* Class::getToString() const {
 187   return m_toString;
 188 }
 189
 190 inline const Func* Class::get86pinit() const {
 191   return m_pinitVec.back();
 192 }
 193
 194 inline const Func* Class::get86sinit() const {
 195   return m_sinitVec.back();
 196 }
 197
 198 inline const Func* Class::get86linit() const {
 199   return m_linitVec.back();
 200 }
 201
 202 ///////////////////////////////////////////////////////////////////////////////
 203 // Builtin classes.
 204
 205 inline bool Class::isBuiltin() const {
 206   return attrs() & AttrBuiltin;
 207 }
 208
 209 inline BuiltinCtorFunction Class::instanceCtor() const {
 210   return m_extra->m_instanceCtor;
 211 }
 212
 213 inline BuiltinDtorFunction Class::instanceDtor() const {
 214   return m_extra->m_instanceDtor;
 215 }
 216
 217 ///////////////////////////////////////////////////////////////////////////////
 218 // Methods.
 219
 220 inline size_t Class::numMethods() const {
 221   return m_methods.size();
 222 }
 223
 224 inline Func* Class::getMethod(Slot idx) const {
 225   auto funcVec = (LowPtr<Func>*)this;
 226   return funcVec[-((int32_t)idx + 1)];
 227 }
 228
 229 inline void Class::setMethod(Slot idx, Func* func) {
 230   auto funcVec = (LowPtr<Func>*)this;
 231   funcVec[-((int32_t)idx + 1)] = func;
 232 }
 233
 234 inline Func* Class::lookupMethod(const StringData* methName) const {
 235   Slot* idx = m_methods.find(methName);
 236   if (!idx) return nullptr;
 237   return getMethod(*idx);
 238 }
 239
 240 ///////////////////////////////////////////////////////////////////////////////
 241 // Property metadata.
 242
 243 inline size_t Class::numDeclProperties() const {
 244   return m_declProperties.size();
 245 }
 246
 247 inline size_t Class::numStaticProperties() const {
 248   return m_staticProperties.size();
 249 }
 250
 251 inline uint32_t Class::declPropNumAccessible() const {
 252   return m_declPropNumAccessible;
 253 }
 254
 255 inline folly::Range<const Class::Prop*> Class::declProperties() const {
 256   return m_declProperties.range();
 257 }
 258
 259 inline folly::Range<const Class::SProp*> Class::staticProperties() const {
 260   return m_staticProperties.range();
 261 }
 262
 263 inline Slot Class::lookupDeclProp(const StringData* propName) const {
 264   return m_declProperties.findIndex(propName);
 265 }
 266
 267 inline Slot Class::lookupSProp(const StringData* sPropName) const {
 268   return m_staticProperties.findIndex(sPropName);
 269 }
 270
 271 extern const StaticString s_86reified_prop;
 272
 273 inline Slot Class::lookupReifiedInitProp() const {
 274   return m_declProperties.findIndex(s_86reified_prop.get());
 275 }
 276
 277 inline RepoAuthType Class::declPropRepoAuthType(Slot index) const {
 278   return m_declProperties[index].repoAuthType;
 279 }
 280
 281 inline RepoAuthType Class::staticPropRepoAuthType(Slot index) const {
 282   return m_staticProperties[index].repoAuthType;
 283 }
 284
 285 inline const TypeConstraint& Class::declPropTypeConstraint(Slot index) const {
 286   return m_declProperties[index].typeConstraint;
 287 }
 288
 289 inline const TypeConstraint& Class::staticPropTypeConstraint(Slot index) const {
 290   return m_staticProperties[index].typeConstraint;
 291 }
 292
 293 inline bool Class::hasDeepInitProps() const {
 294   return m_hasDeepInitProps;
 295 }
 296
 297 inline bool Class::forbidsDynamicProps() const {
 298   return attrs() & AttrForbidDynamicProps;
 299 }
 300
 301 inline bool Class::hasImmutableProps() const {
 302   return attrs() & AttrHasImmutable;
 303 }
 304
 305 inline bool Class::serialize() const {
 306   if (m_serialized) return false;
 307   m_serialized = true;
 308   return true;
 309 }
 310
 311 inline bool Class::wasSerialized() const {
 312   return m_serialized;
 313 }
 314
 315 ///////////////////////////////////////////////////////////////////////////////
 316 // Property initialization.
 317
 318 inline bool Class::needInitialization() const {
 319   return m_needInitialization;
 320 }
 321
 322 inline bool Class::maybeRedefinesPropTypes() const {
 323   return m_maybeRedefsPropTy;
 324 }
 325
 326 inline bool Class::needsPropInitialValueCheck() const {
 327   return m_needsPropInitialCheck;
 328 }
 329
 330 inline const Class::PropInitVec& Class::declPropInit() const {
 331   return m_declPropInit;
 332 }
 333
 334 inline const VMFixedVector<const Func*>& Class::pinitVec() const {
 335   return m_pinitVec;
 336 }
 337
 338 inline rds::Handle Class::checkedPropTypeRedefinesHandle() const {
 339   assertx(m_maybeRedefsPropTy);
 340   m_extra->m_checkedPropTypeRedefs.bind(rds::Mode::Normal);
 341   return m_extra->m_checkedPropTypeRedefs.handle();
 342 }
 343
 344 inline rds::Handle Class::checkedPropInitialValuesHandle() const {
 345   assertx(m_needsPropInitialCheck);
 346   m_extra->m_checkedPropInitialValues.bind(rds::Mode::Normal);
 347   return m_extra->m_checkedPropInitialValues.handle();
 348 }
 349
 350 ///////////////////////////////////////////////////////////////////////////////
 351 // Property storage.
 352
 353 inline void Class::initPropHandle() const {
 354   m_propDataCache.bind(rds::Mode::Normal);
 355 }
 356
 357 inline rds::Handle Class::propHandle() const {
 358   return m_propDataCache.handle();
 359 }
 360
 361 inline rds::Handle Class::sPropInitHandle() const {
 362   return m_sPropCacheInit.handle();
 363 }
 364
 365 inline rds::Handle Class::sPropHandle(Slot index) const {
 366   return sPropLink(index).handle();
 367 }
 368
 369 inline rds::Link<StaticPropData, rds::Mode::NonNormal>
 370 Class::sPropLink(Slot index) const {
 371   assertx(m_sPropCacheInit.bound());
 372   assertx(numStaticProperties() > index);
 373   return m_sPropCache[index];
 374 }
 375
 376 inline rds::Link<bool, rds::Mode::NonLocal> Class::sPropInitLink() const {
 377   return m_sPropCacheInit;
 378 }
 379
 380 ///////////////////////////////////////////////////////////////////////////////
 381 // Constants.
 382
 383 inline size_t Class::numConstants() const {
 384   return m_constants.size();
 385 }
 386
 387 inline const Class::Const* Class::constants() const {
 388   return m_constants.accessList();
 389 }
 390
 391 inline bool Class::hasConstant(const StringData* clsCnsName) const {
 392   // m_constants.contains(clsCnsName) returns abstract constants
 393   auto clsCnsInd = m_constants.findIndex(clsCnsName);
 394   return (clsCnsInd != kInvalidSlot) &&
 395     !m_constants[clsCnsInd].isAbstract() &&
 396     !m_constants[clsCnsInd].isType();
 397 }
 398
 399 inline bool Class::hasTypeConstant(const StringData* typeConstName,
 400                                    bool includeAbs) const {
 401   auto typeConstInd = m_constants.findIndex(typeConstName);
 402   return (typeConstInd != kInvalidSlot) &&
 403     (!m_constants[typeConstInd].isAbstract() || includeAbs) &&
 404     m_constants[typeConstInd].isType();
 405 }
 406
 407 ///////////////////////////////////////////////////////////////////////////////
 408 // Interfaces and traits.
 409
 410 inline folly::Range<const ClassPtr*> Class::declInterfaces() const {
 411   return folly::range(m_declInterfaces.begin(),
 412                       m_declInterfaces.end());
 413 }
 414
 415 inline const Class::InterfaceMap& Class::allInterfaces() const {
 416   return m_interfaces;
 417 }
 418
 419 inline Slot Class::traitsBeginIdx() const {
 420   return m_extra->m_traitsBeginIdx;
 421 }
 422
 423 inline Slot Class::traitsEndIdx() const   {
 424   return m_extra->m_traitsEndIdx;
 425 }
 426
 427 inline const VMCompactVector<ClassPtr>& Class::usedTraitClasses() const {
 428   return m_extra->m_usedTraits;
 429 }
 430
 431 inline const Class::TraitAliasVec& Class::traitAliases() const {
 432   return m_extra->m_traitAliases;
 433 }
 434
 435 inline void Class::addTraitAlias(const PreClass::TraitAliasRule& rule) const {
 436   allocExtraData();
 437   m_extra.raw()->m_traitAliases.push_back(rule.asNamePair());
 438 }
 439
 440 inline const Class::RequirementMap& Class::allRequirements() const {
 441   return m_requirements;
 442 }
 443
 444 ///////////////////////////////////////////////////////////////////////////////
 445 // Instance bits.
 446
 447 inline bool Class::checkInstanceBit(unsigned int bit) const {
 448   assertx(bit > 0);
 449   return m_instanceBits[bit];
 450 }
 451
 452 ///////////////////////////////////////////////////////////////////////////////
 453 // Throwable initialization.
 454
 455 inline bool Class::needsInitThrowable() const {
 456   return m_needsInitThrowable;
 457 }
 458
 459 ///////////////////////////////////////////////////////////////////////////////
 460 // JIT data.
 461
 462 inline rds::Handle Class::classHandle() const {
 463   return m_cachedClass.handle();
 464 }
 465
 466 inline void Class::setClassHandle(rds::Link<LowPtr<Class>,
 467                                             rds::Mode::NonLocal> link) const {
 468   assertx(!m_cachedClass.bound());
 469   m_cachedClass = link;
 470 }
 471
 472 inline Class* Class::getCached() const {
 473   return m_cachedClass.isInit() ? *m_cachedClass : nullptr;
 474 }
 475
 476 inline void Class::setCached() {
 477   m_cachedClass.initWith(this);
 478 }
 479
 480 ///////////////////////////////////////////////////////////////////////////////
 481 // Native data.
 482
 483 inline const Native::NativeDataInfo* Class::getNativeDataInfo() const {
 484   return m_extra->m_nativeDataInfo;
 485 }
 486
 487 ///////////////////////////////////////////////////////////////////////////////
 488 // Closure subclasses.
 489
 490 inline bool Class::isScopedClosure() const {
 491   return m_scoped;
 492 }
 493
 494 inline const Class::ScopedClonesMap& Class::scopedClones() const {
 495   return m_extra->m_scopedClones;
 496 }
 497
 498 /////////////////////////////////////////////////////////////////////////////
 499 // Memoization
 500
 501 inline size_t Class::numMemoSlots() const {
 502   return m_extra->m_nextMemoSlot;
 503 }
 504
 505 inline bool Class::hasMemoSlots() const {
 506   return numMemoSlots() > 0;
 507 }
 508
 509 inline std::pair<Slot, bool> Class::memoSlotForFunc(FuncId func) const {
 510   assertx(hasMemoSlots());
 511   auto const it = m_extra->m_memoMappings.find(func);
 512   if (it != m_extra->m_memoMappings.end()) return it->second;
 513   // Each mapping is only stored in the class which defines it, so recurse up to
 514   // the parent. We should only be calling this with functions which have a memo
 515   // slot, so assert if we reach the end without finding a slot.
 516   if (m_parent) return m_parent->memoSlotForFunc(func);
 517   always_assert(false);
 518 }
 519
 520 ///////////////////////////////////////////////////////////////////////////////
 521 // Other methods.
 522
 523 inline MaybeDataType Class::enumBaseTy() const {
 524   return m_enumBaseTy;
 525 }
 526
 527 inline EnumValues* Class::getEnumValues() const {
 528   return m_extra->m_enumValues.load(std::memory_order_relaxed);
 529 }
 530
 531 ///////////////////////////////////////////////////////////////////////////////
 532 // ExtraData.
 533
 534 inline void Class::allocExtraData() const {
 535   if (!m_extra) {
 536     m_extra = new ExtraData();
 537   }
 538 }
 539
 540 ///////////////////////////////////////////////////////////////////////////////
 541 // Non-member functions.
 542
 543 inline Attr classKindAsAttr(ClassKind kind) {
 544   return static_cast<Attr>(kind);
 545 }
 546
 547 inline bool isTrait(const Class* cls) {
 548   return cls->attrs() & AttrTrait;
 549 }
 550
 551 inline bool isEnum(const Class* cls) {
 552   return cls->attrs() & AttrEnum;
 553 }
 554
 555 inline bool isInterface(const Class* cls) {
 556   return cls->attrs() & AttrInterface;
 557 }
 558
 559 inline bool isNormalClass(const Class* cls) {
 560   return !(cls->attrs() & (AttrTrait | AttrInterface | AttrEnum));
 561 }
 562
 563 inline bool isAbstract(const Class* cls) {
 564   return cls->attrs() & AttrAbstract;
 565 }
 566
 567 inline bool classHasPersistentRDS(const Class* cls) {
 568   return cls != nullptr &&
 569     rds::isPersistentHandle(cls->classHandle());
 570 }
 571
 572 inline bool classMayHaveMagicPropMethods(const Class* cls) {
 573   auto constexpr no_overrides =
 574     AttrNoOverrideMagicGet |
 575     AttrNoOverrideMagicSet |
 576     AttrNoOverrideMagicIsset |
 577     AttrNoOverrideMagicUnset;
 578
 579   return (cls->attrs() & no_overrides) != no_overrides;
 580 }
 581
 582 inline const StringData* classToStringHelper(const Class* cls) {
 583  if (RuntimeOption::EvalRaiseClassConversionWarning) {
 584    raise_warning("Class to string conversion");
 585  }
 586  return cls->name();
 587 }
 588 ///////////////////////////////////////////////////////////////////////////////
 589 }