hphp/runtime/vm/func-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_FUNC_INL_H_
  18 #error "func-inl.h should only be included by func.h"
  19 #endif
  20
  21 namespace HPHP {
  22 ///////////////////////////////////////////////////////////////////////////////
  23 // EH and FPI tables.
  24
  25 template<class SerDe>
  26 void FPIEnt::serde(SerDe& sd) {
  27   sd(m_fpushOff)
  28     (m_fcallOff)
  29     (m_fpOff)
  30     // These fields are recomputed by sortFPITab:
  31     // (m_parentIndex)
  32     // (m_fpiDepth)
  33     ;
  34 }
  35
  36 ///////////////////////////////////////////////////////////////////////////////
  37 // ParamInfo.
  38
  39 inline Func::ParamInfo::ParamInfo()
  40   : defaultValue(make_tv<KindOfUninit>())
  41 {}
  42
  43 template<class SerDe>
  44 inline void Func::ParamInfo::serde(SerDe& sd) {
  45   sd(builtinType)
  46     (funcletOff)
  47     (defaultValue)
  48     (phpCode)
  49     (typeConstraint)
  50     (variadic)
  51     (userAttributes)
  52     (userType)
  53     ;
  54 }
  55
  56 inline bool Func::ParamInfo::hasDefaultValue() const {
  57   return funcletOff != InvalidAbsoluteOffset;
  58 }
  59
  60 inline bool Func::ParamInfo::hasScalarDefaultValue() const {
  61   return hasDefaultValue() && defaultValue.m_type != KindOfUninit;
  62 }
  63
  64 inline bool Func::ParamInfo::isVariadic() const {
  65   return variadic;
  66 }
  67
  68 ///////////////////////////////////////////////////////////////////////////////
  69 // Func.
  70
  71 inline const void* Func::mallocEnd() const {
  72   return reinterpret_cast<const char*>(this)
  73          + Func::prologueTableOff()
  74          + numPrologues() * sizeof(m_prologueTable[0]);
  75 }
  76
  77 inline void Func::validate() const {
  78 #ifdef DEBUG
  79   assert(m_magic == kMagic);
  80 #endif
  81   assert(m_name != nullptr);
  82 }
  83
  84 ///////////////////////////////////////////////////////////////////////////////
  85 // FuncId manipulation.
  86
  87 inline FuncId Func::getFuncId() const {
  88   assert(m_funcId != InvalidFuncId);
  89   assert(fromFuncId(m_funcId) == this);
  90   return m_funcId;
  91 }
  92
  93 ///////////////////////////////////////////////////////////////////////////////
  94 // Basic info.
  95
  96 inline bool Func::top() const {
  97   return shared()->m_top;
  98 }
  99
 100 inline Unit* Func::unit() const {
 101   return m_unit;
 102 }
 103
 104 inline Class* Func::cls() const {
 105   return m_cls;
 106 }
 107
 108 inline PreClass* Func::preClass() const {
 109   return shared()->m_preClass;
 110 }
 111
 112 inline Class* Func::baseCls() const {
 113   return m_baseCls;
 114 }
 115
 116 inline Class* Func::implCls() const {
 117   return isClosureBody() ? baseCls() : cls();
 118 }
 119
 120 inline const StringData* Func::name() const {
 121   assert(m_name != nullptr);
 122   return m_name;
 123 }
 124
 125 inline StrNR Func::nameStr() const {
 126   assert(m_name != nullptr);
 127   return StrNR(m_name);
 128 }
 129
 130 inline const StringData* Func::fullName() const {
 131   if (m_fullName == nullptr) return m_name;
 132   return m_fullName;
 133 }
 134
 135 inline StrNR Func::fullNameStr() const {
 136   assert(m_fullName != nullptr);
 137   return StrNR(m_fullName);
 138 }
 139
 140 inline const StringData* Func::displayName() const {
 141   auto const target = dynCallTarget();
 142   return LIKELY(!target) ? name() : target->name();
 143 }
 144
 145 inline const StringData* Func::fullDisplayName() const {
 146   auto const target = dynCallTarget();
 147   return LIKELY(!target) ? fullName() : target->fullName();
 148 }
 149
 150 inline const NamedEntity* Func::getNamedEntity() const {
 151   assert(!shared()->m_preClass);
 152   return *reinterpret_cast<const LowPtr<const NamedEntity>*>(&m_namedEntity);
 153 }
 154
 155 inline void Func::setNamedEntity(const NamedEntity* e) {
 156   *reinterpret_cast<LowPtr<const NamedEntity>*>(&m_namedEntity) = e;
 157 }
 158
 159 ///////////////////////////////////////////////////////////////////////////////
 160 // File info.
 161
 162 inline const StringData* Func::originalFilename() const {
 163   return shared()->m_originalFilename;
 164 }
 165
 166 inline const StringData* Func::filename() const {
 167   // Builtins don't have filenames
 168   if (isBuiltin()) {
 169     return staticEmptyString();
 170   }
 171
 172   // Use the original filename if it exists, otherwise grab the filename from
 173   // the unit
 174   const StringData* name = originalFilename();
 175   if (!name) {
 176     assert(m_unit);
 177     name = m_unit->filepath();
 178     assert(name);
 179   }
 180   return name;
 181 }
 182
 183 inline int Func::line1() const {
 184   return shared()->m_line1;
 185 }
 186
 187 inline int Func::line2() const {
 188   auto const sd = shared();
 189   auto const delta = sd->m_line2Delta;
 190   if (UNLIKELY(delta == kSmallDeltaLimit)) {
 191     assert(extShared());
 192     return static_cast<const ExtendedSharedData*>(sd)->m_line2;
 193   }
 194   return line1() + delta;
 195 }
 196
 197 inline const StringData* Func::docComment() const {
 198   return shared()->m_docComment;
 199 }
 200
 201 ///////////////////////////////////////////////////////////////////////////////
 202 // Bytecode.
 203
 204 inline PC Func::getEntry() const {
 205   return m_unit->entry() + shared()->m_base;
 206 }
 207
 208 inline Offset Func::base() const {
 209   return shared()->m_base;
 210 }
 211
 212 inline Offset Func::past() const {
 213   auto const sd = shared();
 214   auto const delta = sd->m_pastDelta;
 215   if (UNLIKELY(delta == kSmallDeltaLimit)) {
 216     assert(extShared());
 217     return static_cast<const ExtendedSharedData*>(sd)->m_past;
 218   }
 219   return base() + delta;
 220 }
 221
 222 inline bool Func::contains(PC pc) const {
 223   return contains(Offset(pc - unit()->entry()));
 224 }
 225
 226 inline bool Func::contains(Offset offset) const {
 227   return offset >= base() && offset < past();
 228 }
 229
 230 ///////////////////////////////////////////////////////////////////////////////
 231 // Return type.
 232
 233 inline MaybeDataType Func::hniReturnType() const {
 234   auto const ex = extShared();
 235   return ex ? ex->m_hniReturnType : folly::none;
 236 }
 237
 238 inline RepoAuthType Func::repoReturnType() const {
 239   return shared()->m_repoReturnType;
 240 }
 241
 242 inline RepoAuthType Func::repoAwaitedReturnType() const {
 243   return shared()->m_repoAwaitedReturnType;
 244 }
 245
 246 inline bool Func::isReturnByValue() const {
 247   return shared()->m_returnByValue;
 248 }
 249
 250 inline bool Func::isReturnRef() const {
 251   return m_attrs & AttrReference;
 252 }
 253
 254 inline const TypeConstraint& Func::returnTypeConstraint() const {
 255   return shared()->m_retTypeConstraint;
 256 }
 257
 258 inline const StringData* Func::returnUserType() const {
 259   return shared()->m_retUserType;
 260 }
 261
 262 ///////////////////////////////////////////////////////////////////////////////
 263 // Parameters.
 264
 265 inline const Func::ParamInfoVec& Func::params() const {
 266   return shared()->m_params;
 267 }
 268
 269 inline uint32_t Func::numParams() const {
 270   assert(bool(m_attrs & AttrVariadicParam) != bool(m_paramCounts & 1));
 271   assert((m_paramCounts >> 1) == params().size());
 272   return (m_paramCounts) >> 1;
 273 }
 274
 275 inline uint32_t Func::numNonVariadicParams() const {
 276   assert(bool(m_attrs & AttrVariadicParam) != bool(m_paramCounts & 1));
 277   assert((m_paramCounts >> 1) == params().size());
 278   return (m_paramCounts - 1) >> 1;
 279 }
 280
 281 inline bool Func::hasVariadicCaptureParam() const {
 282 #ifdef DEBUG
 283   assert(bool(m_attrs & AttrVariadicParam) ==
 284          (numParams() && params()[numParams() - 1].variadic));
 285 #endif
 286   return m_attrs & AttrVariadicParam;
 287 }
 288
 289 inline bool Func::discardExtraArgs() const {
 290   return !(m_attrs & (AttrMayUseVV | AttrVariadicParam));
 291 }
 292
 293 ///////////////////////////////////////////////////////////////////////////////
 294 // Locals, iterators, and stack.
 295
 296 inline int Func::numLocals() const {
 297   return shared()->m_numLocals;
 298 }
 299
 300 inline int Func::numIterators() const {
 301   return shared()->m_numIterators;
 302 }
 303
 304 inline Id Func::numNamedLocals() const {
 305   return shared()->m_localNames.size();
 306 }
 307
 308 inline const StringData* Func::localVarName(Id id) const {
 309   assert(id >= 0);
 310   return id < numNamedLocals() ? shared()->m_localNames[id] : nullptr;
 311 }
 312
 313 inline LowStringPtr const* Func::localNames() const {
 314   return shared()->m_localNames.accessList();
 315 }
 316
 317 inline int Func::maxStackCells() const {
 318   return m_maxStackCells;
 319 }
 320
 321 inline int Func::numSlotsInFrame() const {
 322   return shared()->m_numLocals +
 323     shared()->m_numIterators * (sizeof(Iter) / sizeof(Cell));
 324 }
 325
 326 inline bool Func::hasForeignThis() const {
 327   return attrs() & AttrHasForeignThis;
 328 }
 329
 330 ///////////////////////////////////////////////////////////////////////////////
 331 // Static locals.
 332
 333 inline const Func::SVInfoVec& Func::staticVars() const {
 334   return shared()->m_staticVars;
 335 }
 336
 337 inline bool Func::hasStaticLocals() const {
 338   return !shared()->m_staticVars.empty();
 339 }
 340
 341 inline int Func::numStaticLocals() const {
 342   return shared()->m_staticVars.size();
 343 }
 344
 345 ///////////////////////////////////////////////////////////////////////////////
 346 // Definition context.
 347
 348 inline bool Func::isPseudoMain() const {
 349   return m_name->empty();
 350 }
 351
 352 inline bool Func::isMethod() const {
 353   return !isPseudoMain() && (bool)baseCls();
 354 }
 355
 356 inline bool Func::isFromTrait() const {
 357   return m_attrs & AttrTrait;
 358 }
 359
 360 inline bool Func::isPublic() const {
 361   return m_attrs & AttrPublic;
 362 }
 363
 364 inline bool Func::isStatic() const {
 365   return m_attrs & AttrStatic;
 366 }
 367
 368 inline bool Func::isStaticInPrologue() const {
 369   return (m_attrs & (AttrStatic | AttrRequiresThis)) == AttrStatic;
 370 }
 371
 372 inline bool Func::requiresThisInBody() const {
 373   return (m_attrs & AttrRequiresThis) && !isClosureBody();
 374 }
 375
 376 inline bool Func::hasThisVaries() const {
 377   return mayHaveThis() && !requiresThisInBody();
 378 }
 379
 380 inline bool Func::isAbstract() const {
 381   return m_attrs & AttrAbstract;
 382 }
 383
 384 inline bool Func::mayHaveThis() const {
 385   return cls() && !isStatic();
 386 }
 387
 388 inline bool Func::isPreFunc() const {
 389   return m_isPreFunc;
 390 }
 391
 392 inline bool Func::isMemoizeWrapper() const {
 393   return shared()->m_isMemoizeWrapper;
 394 }
 395
 396 inline const StringData* Func::memoizeImplName() const {
 397   assertx(isMemoizeWrapper());
 398   return genMemoizeImplName(name());
 399 }
 400
 401 ///////////////////////////////////////////////////////////////////////////////
 402 // Builtins.
 403
 404 inline bool Func::isBuiltin() const {
 405   return m_attrs & AttrBuiltin;
 406 }
 407
 408 inline bool Func::isCPPBuiltin() const {
 409   auto const ex = extShared();
 410   return UNLIKELY(!!ex) && ex->m_builtinFuncPtr;
 411 }
 412
 413 inline bool Func::readsCallerFrame() const {
 414   return m_attrs & AttrReadsCallerFrame;
 415 }
 416
 417 inline bool Func::writesCallerFrame() const {
 418   return m_attrs & AttrWritesCallerFrame;
 419 }
 420
 421 inline bool Func::accessesCallerFrame() const {
 422   return m_attrs & (AttrReadsCallerFrame | AttrWritesCallerFrame);
 423 }
 424
 425 inline BuiltinFunction Func::builtinFuncPtr() const {
 426   if (auto const ex = extShared()) {
 427     if (UNLIKELY(ex->m_dynCallTarget != nullptr)) {
 428       return ex->m_dynCallTarget->builtinFuncPtr();
 429     }
 430     return ex->m_builtinFuncPtr;
 431   }
 432   return nullptr;
 433 }
 434
 435 inline BuiltinFunction Func::nativeFuncPtr() const {
 436   if (auto const ex = extShared()) {
 437     if (UNLIKELY(ex->m_dynCallTarget != nullptr)) {
 438       return ex->m_dynCallTarget->nativeFuncPtr();
 439     }
 440     return ex->m_nativeFuncPtr;
 441   }
 442   return nullptr;
 443 }
 444
 445 inline Func* Func::dynCallWrapper() const {
 446   if (auto const ex = extShared()) {
 447     return ex->m_dynCallWrapper;
 448   }
 449   return nullptr;
 450 }
 451
 452 inline Func* Func::dynCallTarget() const {
 453   if (auto const ex = extShared()) {
 454     return ex->m_dynCallTarget;
 455   }
 456   return nullptr;
 457 }
 458
 459 ///////////////////////////////////////////////////////////////////////////////
 460 // Closures.
 461
 462 inline bool Func::isClosureBody() const {
 463   return shared()->m_isClosureBody;
 464 }
 465
 466 ///////////////////////////////////////////////////////////////////////////////
 467 // Resumables.
 468
 469 inline bool Func::isAsync() const {
 470   return shared()->m_isAsync;
 471 }
 472
 473 inline bool Func::isGenerator() const {
 474   return shared()->m_isGenerator;
 475 }
 476
 477 inline bool Func::isPairGenerator() const {
 478   return shared()->m_isPairGenerator;
 479 }
 480
 481 inline bool Func::isAsyncFunction() const {
 482   return isAsync() && !isGenerator();
 483 }
 484
 485 inline bool Func::isNonAsyncGenerator() const {
 486   return !isAsync() && isGenerator();
 487 }
 488
 489 inline bool Func::isAsyncGenerator() const {
 490   return isAsync() && isGenerator();
 491 }
 492
 493 inline bool Func::isResumable() const {
 494   return isAsync() || isGenerator();
 495 }
 496
 497 ///////////////////////////////////////////////////////////////////////////////
 498 // Methods.
 499
 500 inline Slot Func::methodSlot() const {
 501   assert(isMethod());
 502   return m_methodSlot;
 503 }
 504
 505 inline bool Func::hasPrivateAncestor() const {
 506   return m_hasPrivateAncestor;
 507 }
 508
 509 ///////////////////////////////////////////////////////////////////////////////
 510 // Magic methods.
 511
 512 inline bool Func::isGenerated() const {
 513   return shared()->m_isGenerated;
 514 }
 515
 516 inline bool Func::isDestructor() const {
 517   return !strcmp(m_name->data(), "__destruct");
 518 }
 519
 520 inline bool Func::isMagic() const {
 521   return isMagicCallMethod() || isMagicCallStaticMethod();
 522 }
 523
 524 inline bool Func::isMagicCallMethod() const {
 525   return m_name->isame(s___call);
 526 }
 527
 528 inline bool Func::isMagicCallStaticMethod() const {
 529   return m_name->isame(s___callStatic);
 530 }
 531
 532 inline bool Func::isSpecial(const StringData* name) {
 533   return strncmp("86", name->data(), 2) == 0;
 534 }
 535
 536 ///////////////////////////////////////////////////////////////////////////////
 537 // Other attributes.
 538
 539 inline Attr Func::attrs() const {
 540   return m_attrs;
 541 }
 542
 543 inline const UserAttributeMap& Func::userAttributes() const {
 544   return shared()->m_userAttributes;
 545 }
 546
 547 inline bool Func::isUnique() const {
 548   return m_attrs & AttrUnique;
 549 }
 550
 551 inline bool Func::isPersistent() const {
 552   return m_attrs & AttrPersistent;
 553 }
 554
 555 inline bool Func::isNoInjection() const {
 556   return m_attrs & AttrNoInjection;
 557 }
 558
 559 inline bool Func::isSkipFrame() const {
 560   return m_attrs & AttrSkipFrame;
 561 }
 562
 563 inline bool Func::isFoldable() const {
 564   return m_attrs & AttrIsFoldable;
 565 }
 566
 567 inline bool Func::isParamCoerceMode() const {
 568   return attrs() & (AttrParamCoerceModeFalse | AttrParamCoerceModeNull);
 569 }
 570
 571 ///////////////////////////////////////////////////////////////////////////////
 572 // Unit table entries.
 573
 574 inline const Func::EHEntVec& Func::ehtab() const {
 575   return shared()->m_ehtab;
 576 }
 577
 578 inline const Func::FPIEntVec& Func::fpitab() const {
 579   return shared()->m_fpitab;
 580 }
 581
 582 inline const FPIEnt* Func::findFPI(Offset o) const {
 583   assertx(o >= base() && o < past());
 584   return findFPI(fpitab().begin(), fpitab().end(), o);
 585 }
 586
 587 ///////////////////////////////////////////////////////////////////////////////
 588 // JIT data.
 589
 590 inline rds::Handle Func::funcHandle() const {
 591   return m_cachedFunc.handle();
 592 }
 593
 594 inline unsigned char* Func::getFuncBody() const {
 595   return m_funcBody;
 596 }
 597
 598 inline void Func::setFuncBody(unsigned char* fb) {
 599   m_funcBody = fb;
 600 }
 601
 602 inline uint8_t* Func::getPrologue(int index) const {
 603   return m_prologueTable[index];
 604 }
 605
 606 inline void Func::setPrologue(int index, unsigned char* tca) {
 607   m_prologueTable[index] = tca;
 608 }
 609
 610 ///////////////////////////////////////////////////////////////////////////////
 611 // Other methods.
 612
 613 inline int8_t& Func::maybeIntercepted() const {
 614   return m_maybeIntercepted;
 615 }
 616
 617 ///////////////////////////////////////////////////////////////////////////////
 618 // Public setters.
 619
 620 inline void Func::setAttrs(Attr attrs) {
 621   m_attrs = attrs;
 622   assertx(IMPLIES(accessesCallerFrame(), isBuiltin() && !isMethod()));
 623 }
 624
 625 inline void Func::setBaseCls(Class* baseCls) {
 626   m_baseCls = baseCls;
 627 }
 628
 629 inline void Func::setFuncHandle(rds::Link<LowPtr<Func>> l) {
 630   // TODO(#2950356): This assertion fails for create_function with an existing
 631   // declared function named __lambda_func.
 632   //assert(!m_cachedFunc.valid());
 633   m_cachedFunc = l;
 634 }
 635
 636 inline void Func::setHasPrivateAncestor(bool b) {
 637   m_hasPrivateAncestor = b;
 638 }
 639
 640 inline void Func::setMethodSlot(Slot s) {
 641   assert(isMethod());
 642   m_methodSlot = s;
 643 }
 644
 645 inline void Func::setDynCallWrapper(Func* f) {
 646   assert(accessesCallerFrame());
 647   assert(f->accessesCallerFrame());
 648   assert(!f->dynCallWrapper());
 649   assert(extShared());
 650   assert(!dynCallWrapper() || dynCallWrapper() == f);
 651   assert(!dynCallTarget());
 652   assert(!f->dynCallTarget() || f->dynCallTarget() == this);
 653   extShared()->m_dynCallWrapper = f;
 654 }
 655
 656 inline void Func::setDynCallTarget(Func* f) {
 657   assert(accessesCallerFrame());
 658   assert(f->accessesCallerFrame());
 659   assert(!f->dynCallTarget());
 660   assert(extShared());
 661   assert(!dynCallTarget() || dynCallTarget() == f);
 662   assert(!dynCallWrapper());
 663   assert(!f->dynCallWrapper() || f->dynCallWrapper() == this);
 664   extShared()->m_dynCallTarget = f;
 665 }
 666
 667 //////////////////////////////////////////////////////////////////////
 668
 669 inline const Func::ExtendedSharedData* Func::extShared() const {
 670   return const_cast<Func*>(this)->extShared();
 671 }
 672
 673 inline Func::ExtendedSharedData* Func::extShared() {
 674   auto const s = shared();
 675   return UNLIKELY(s->m_hasExtendedSharedData)
 676     ? static_cast<ExtendedSharedData*>(s)
 677     : nullptr;
 678 }
 679
 680 ///////////////////////////////////////////////////////////////////////////////
 681 }