hphp/runtime/vm/class-inl.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-2014 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 namespace HPHP {
  22 ///////////////////////////////////////////////////////////////////////////////
  23
  24 inline bool Class::isZombie() const {
  25   return !m_cachedClass.bound();
  26 }
  27
  28 ///////////////////////////////////////////////////////////////////////////////
  29 // Class::PropInitVec.
  30
  31 inline Class::PropInitVec::iterator Class::PropInitVec::begin() {
  32   return m_data;
  33 }
  34
  35 inline Class::PropInitVec::iterator Class::PropInitVec::end() {
  36   return m_data + m_size;
  37 }
  38
  39 inline size_t Class::PropInitVec::size() const {
  40   return m_size;
  41 }
  42
  43 inline TypedValueAux& Class::PropInitVec::operator[](size_t i) {
  44   assert(i < m_size);
  45   return m_data[i];
  46 }
  47
  48 inline const TypedValueAux& Class::PropInitVec::operator[](size_t i) const {
  49   assert(i < m_size);
  50   return m_data[i];
  51 }
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54 // Pre- and post-allocations.
  55
  56 inline const LowClassPtr* Class::classVec() const {
  57   return m_classVec;
  58 }
  59
  60 inline unsigned Class::classVecLen() const {
  61   return m_classVecLen;
  62 }
  63
  64 ///////////////////////////////////////////////////////////////////////////////
  65 // Ancestry.
  66
  67 inline uint64_t Class::classof(const Class* cls) const {
  68   // If `cls' is an interface, we can simply check to see if cls is in
  69   // this->m_interfaces.  Otherwise, if `this' is not an interface, the
  70   // classVec check will determine whether it's an instance of cls (including
  71   // the case where this and cls are the same trait).  Otherwise, `this' is an
  72   // interface, and `cls' is not, so we need to return false.  But the classVec
  73   // check can never return true in that case (cls's classVec contains only
  74   // non-interfaces, while this->classVec is either empty, or contains
  75   // interfaces).
  76   if (UNLIKELY(cls->attrs() & AttrInterface)) {
  77     return this == cls ||
  78       m_interfaces.lookupDefault(cls->m_preClass->name(), nullptr) == cls;
  79   }
  80   if (m_classVecLen >= cls->m_classVecLen) {
  81     return (m_classVec[cls->m_classVecLen-1] == cls);
  82   }
  83   return false;
  84 }
  85
  86 inline bool Class::ifaceofDirect(const StringData* name) const {
  87   return m_interfaces.contains(name);
  88 }
  89
  90 ///////////////////////////////////////////////////////////////////////////////
  91 // Basic info.
  92
  93 inline const StringData* Class::name() const {
  94   return m_preClass->name();
  95 }
  96
  97 inline const PreClass* Class::preClass() const {
  98   return m_preClass.get();
  99 }
 100
 101 inline Class* Class::parent() const {
 102   return m_parent.get();
 103 }
 104
 105 inline StrNR Class::nameStr() const {
 106   return m_preClass->nameStr();
 107 }
 108
 109 inline StrNR Class::parentStr() const {
 110   return m_preClass->parentStr();
 111 }
 112
 113 inline Attr Class::attrs() const {
 114   assert(Attr(m_attrCopy) == m_preClass->attrs());
 115   return Attr(m_attrCopy);
 116 }
 117
 118 inline int Class::getODAttrs() const {
 119   return m_ODAttrs;
 120 }
 121
 122 inline bool Class::isPersistent() const {
 123   return attrs() & AttrPersistent;
 124 }
 125
 126 ///////////////////////////////////////////////////////////////////////////////
 127 // Magic methods.
 128
 129 inline const Func* Class::getCtor() const {
 130   return m_ctor;
 131 }
 132
 133 inline const Func* Class::getDtor() const {
 134   return m_dtor;
 135 }
 136
 137 inline const Func* Class::getToString() const {
 138   return m_toString;
 139 }
 140
 141 ///////////////////////////////////////////////////////////////////////////////
 142 // Builtin classes.
 143
 144 inline bool Class::isBuiltin() const {
 145   return attrs() & AttrBuiltin;
 146 }
 147
 148 inline const ClassInfo* Class::clsInfo() const {
 149   return m_extra->m_clsInfo;
 150 }
 151
 152 inline BuiltinCtorFunction Class::instanceCtor() const {
 153   return m_extra->m_instanceCtor;
 154 }
 155
 156 inline BuiltinDtorFunction Class::instanceDtor() const {
 157   return m_extra->m_instanceDtor;
 158 }
 159
 160 inline int32_t Class::builtinODTailSize() const {
 161   return m_extra->m_builtinODTailSize;
 162 }
 163
 164 ///////////////////////////////////////////////////////////////////////////////
 165 // Methods.
 166
 167 inline size_t Class::numMethods() const {
 168   return m_methods.size();
 169 }
 170
 171 inline Func* Class::getMethod(Slot idx) const {
 172   auto funcVec = (LowFuncPtr*)this;
 173   return funcVec[-((int32_t)idx + 1)];
 174 }
 175
 176 inline void Class::setMethod(Slot idx, Func* func) {
 177   auto funcVec = (LowFuncPtr*)this;
 178   funcVec[-((int32_t)idx + 1)] = func;
 179 }
 180
 181 inline Func* Class::lookupMethod(const StringData* methName) const {
 182   Slot* idx = m_methods.find(methName);
 183   if (!idx) return nullptr;
 184   return getMethod(*idx);
 185 }
 186
 187 ///////////////////////////////////////////////////////////////////////////////
 188 // Property metadata.
 189
 190 inline size_t Class::numDeclProperties() const {
 191   return m_declProperties.size();
 192 }
 193
 194 inline size_t Class::numStaticProperties() const {
 195   return m_staticProperties.size();
 196 }
 197
 198 inline uint32_t Class::declPropNumAccessible() const {
 199   return m_declPropNumAccessible;
 200 }
 201
 202 inline const Class::Prop* Class::declProperties() const {
 203   return m_declProperties.accessList();
 204 }
 205
 206 inline const Class::SProp* Class::staticProperties() const {
 207   return m_staticProperties.accessList();
 208 }
 209
 210 inline Slot Class::lookupDeclProp(const StringData* propName) const {
 211   return m_declProperties.findIndex(propName);
 212 }
 213
 214 inline Slot Class::lookupSProp(const StringData* sPropName) const {
 215   return m_staticProperties.findIndex(sPropName);
 216 }
 217
 218 inline RepoAuthType Class::declPropRepoAuthType(Slot index) const {
 219   return m_declProperties[index].m_repoAuthType;
 220 }
 221
 222 inline RepoAuthType Class::staticPropRepoAuthType(Slot index) const {
 223   return m_staticProperties[index].m_repoAuthType;
 224 }
 225
 226 inline bool Class::hasDeepInitProps() const {
 227   return m_hasDeepInitProps;
 228 }
 229
 230 ///////////////////////////////////////////////////////////////////////////////
 231 // Property initialization.
 232
 233 inline bool Class::needInitialization() const {
 234   return m_needInitialization;
 235 }
 236
 237 inline const Class::PropInitVec& Class::declPropInit() const {
 238   return m_declPropInit;
 239 }
 240
 241 inline const std::vector<const Func*>& Class::pinitVec() const {
 242   return m_pinitVec;
 243 }
 244
 245 ///////////////////////////////////////////////////////////////////////////////
 246 // Property storage.
 247
 248 inline void Class::initPropHandle() const {
 249   m_propDataCache.bind();
 250 }
 251
 252 inline RDS::Handle Class::propHandle() const {
 253   return m_propDataCache.handle();
 254 }
 255
 256 inline RDS::Handle Class::sPropInitHandle() const {
 257   return m_sPropCacheInit.handle();
 258 }
 259
 260 inline RDS::Handle Class::sPropHandle(Slot index) const {
 261   assert(m_sPropCacheInit.bound());
 262   assert(numStaticProperties() > index);
 263   return m_sPropCache[index].handle();
 264 }
 265
 266 ///////////////////////////////////////////////////////////////////////////////
 267 // Constants.
 268
 269 inline size_t Class::numConstants() const {
 270   return m_constants.size();
 271 }
 272
 273 inline const Class::Const* Class::constants() const {
 274   return m_constants.accessList();
 275 }
 276
 277 inline bool Class::hasConstant(const StringData* clsCnsName) const {
 278   return m_constants.contains(clsCnsName);
 279 }
 280
 281 ///////////////////////////////////////////////////////////////////////////////
 282 // Interfaces and traits.
 283
 284 inline boost::iterator_range<const ClassPtr*> Class::declInterfaces() const {
 285   return boost::make_iterator_range(
 286     m_declInterfaces.get(),
 287     m_declInterfaces.get() + m_numDeclInterfaces
 288   );
 289 }
 290
 291 inline const Class::InterfaceMap& Class::allInterfaces() const {
 292   return m_interfaces;
 293 }
 294
 295 inline Slot Class::traitsBeginIdx() const {
 296   return m_extra->m_traitsBeginIdx;
 297 }
 298
 299 inline Slot Class::traitsEndIdx() const   {
 300   return m_extra->m_traitsEndIdx;
 301 }
 302
 303 inline const std::vector<ClassPtr>& Class::usedTraitClasses() const {
 304   return m_extra->m_usedTraits;
 305 }
 306
 307 inline const Class::TraitAliasVec& Class::traitAliases() const {
 308   return m_extra->m_traitAliases;
 309 }
 310
 311 inline const Class::RequirementMap& Class::allRequirements() const {
 312   return m_requirements;
 313 }
 314
 315 ///////////////////////////////////////////////////////////////////////////////
 316 // Objects.
 317
 318 inline bool Class::callsCustomInstanceInit() const {
 319   return m_callsCustomInstanceInit;
 320 }
 321
 322 ///////////////////////////////////////////////////////////////////////////////
 323 // Other methods.
 324
 325 inline RDS::Handle Class::classHandle() const {
 326   return m_cachedClass.handle();
 327 }
 328
 329 inline void Class::setClassHandle(RDS::Link<Class*> link) const {
 330   assert(!m_cachedClass.bound());
 331   m_cachedClass = link;
 332 }
 333
 334 inline Class* Class::getCached() const {
 335   return *m_cachedClass;
 336 }
 337
 338 inline void Class::setCached() {
 339   *m_cachedClass = this;
 340 }
 341
 342 inline const Native::NativeDataInfo* Class::getNativeDataInfo() const {
 343   return m_extra->m_nativeDataInfo;
 344 }
 345
 346 inline DataType Class::enumBaseTy() const {
 347   return m_enumBaseTy;
 348 }
 349
 350 ///////////////////////////////////////////////////////////////////////////////
 351 // ExtraData.
 352
 353 inline void Class::allocExtraData() {
 354   if (!m_extra) {
 355     m_extra = new ExtraData();
 356   }
 357 }
 358
 359 ///////////////////////////////////////////////////////////////////////////////
 360
 361 inline Attr classKindAsAttr(ClassKind kind) {
 362   return static_cast<Attr>(kind);
 363 }
 364
 365 inline bool isTrait(const Class* cls) {
 366   return cls->attrs() & AttrTrait;
 367 }
 368
 369 inline bool isEnum(const Class* cls) {
 370   return cls->attrs() & AttrEnum;
 371 }
 372
 373 inline bool isInterface(const Class* cls) {
 374   return cls->attrs() & AttrInterface;
 375 }
 376
 377 inline bool isNormalClass(const Class* cls ) {
 378   return !(cls->attrs() & (AttrTrait | AttrInterface | AttrEnum));
 379 }
 380
 381 inline bool isAbstract(const Class* cls) {
 382   return cls->attrs() & AttrAbstract;
 383 }
 384
 385 inline bool classHasPersistentRDS(const Class* cls) {
 386   return cls && RDS::isPersistentHandle(cls->classHandle());
 387 }
 388
 389 ///////////////////////////////////////////////////////////////////////////////
 390 }