自学教程：C++ vm_call_user_func函数代码示例

void autoTypecheck(const Unit* unit) {  if (RuntimeOption::RepoAuthoritative ||      !RuntimeOption::AutoTypecheck ||      tl_doneAutoTypecheck ||      !unit->isHHFile()) {    return;  }  tl_doneAutoTypecheck = true;  vm_call_user_func("//HH//Client//typecheck_and_error", staticEmptyArray());}

bool EventHook::RunInterceptHandler(ActRec* ar) {  const Func* func = ar->m_func;  if (LIKELY(func->maybeIntercepted() == 0)) return true;  // Intercept only original generator / async function calls, not resumption.  if (ar->inGenerator()) return true;  Variant *h = get_intercept_handler(func->fullNameRef(),                                     &func->maybeIntercepted());  if (!h) return true;  JIT::VMRegAnchor _;  PC savePc = g_context->m_pc;  Variant doneFlag = true;  Variant called_on;  if (ar->hasThis()) {    called_on = Variant(ar->getThis());  } else if (ar->hasClass()) {    // For static methods, give handler the name of called class    called_on = Variant(const_cast<StringData*>(ar->getClass()->name()));  }  Variant intArgs =    PackedArrayInit(5)      .append(ar->m_func->fullNameRef())      .append(called_on)      .append(get_frame_args_with_ref(ar))      .append(h->asCArrRef()[1])      .appendRef(doneFlag)      .toArray();  Variant ret = vm_call_user_func(h->asCArrRef()[0], intArgs);  if (doneFlag.toBoolean()) {    Offset pcOff;    ActRec* outer = g_context->getPrevVMState(ar, &pcOff);    frame_free_locals_inl_no_hook<true>(ar, ar->m_func->numLocals());    Stack& stack = g_context->getStack();    stack.top() = (Cell*)(ar + 1);    cellDup(*ret.asCell(), *stack.allocTV());    g_context->m_fp = outer;    g_context->m_pc = outer ? outer->m_func->unit()->at(pcOff) : nullptr;    return false;  }  g_context->m_fp = ar;  g_context->m_pc = savePc;  return true;}

void EventHook::DoMemoryThresholdCallback() {  clearSurpriseFlag(MemThresholdFlag);  if (!g_context->m_memThresholdCallback.isNull()) {    VMRegAnchor _;    try {      vm_call_user_func(g_context->m_memThresholdCallback, empty_array());    } catch (Object& ex) {      raise_error("Uncaught exception escaping mem Threshold callback: %s",                  ex.toString().data());    }  }}

bool f_pcntl_signal_dispatch() {  int *signaled = s_signal_handlers->signaled;  for (int i = 0; i < _NSIG; i++) {    if (signaled[i]) {      signaled[i] = 0;      if (s_signal_handlers->handlers.exists(i)) {        vm_call_user_func(s_signal_handlers->handlers[i],                               make_packed_array(i));      }    }  }  return true;}

void IntervalTimer::RunCallbacks() {  for (auto timer : s_timer_pool->timers) {    if (timer->m_signaled.load(std::memory_order_relaxed)) {      timer->m_signaled.store(false, std::memory_order_relaxed);      try {        vm_call_user_func(timer->m_callback, init_null());      } catch (Object& ex) {        raise_error("Uncaught exception escaping IntervalTimer: %s",                    ex.toString().data());      }    }  }}

Variant f_iterator_apply(CVarRef obj, CVarRef func,                         CArrRef params /* = null_array */) {  Object pobj = get_traversable_object_iterator(obj);  pobj->o_invoke_few_args(s_rewind, 0);  int64_t count = 0;  while (same(pobj->o_invoke_few_args(s_valid, 0), true)) {    if (!same(vm_call_user_func(func, params), true)) {      break;    }    ++count;    pobj->o_invoke_few_args(s_next, 0);  }  return count;}

bool HHVM_FUNCTION(pcntl_signal_dispatch) {  if (!signalHandlersInited()) return true;  int *signaled = s_signal_handlers->signaled;  for (int i = 0; i < _NSIG; i++) {    if (signaled[i]) {      signaled[i] = 0;      if (s_signal_handlers->handlers.exists(i)) {        vm_call_user_func(s_signal_handlers->handlers[i],                               make_packed_array(i));      }    }  }  return true;}

bool EventHook::RunInterceptHandler(ActRec* ar) {  const Func* func = ar->m_func;  if (LIKELY(func->maybeIntercepted() == 0)) return true;  Variant *h = get_intercept_handler(func->fullNameRef(),                                     &func->maybeIntercepted());  if (!h) return true;  Transl::VMRegAnchor _;  PC savePc = g_vmContext->m_pc;  Variant doneFlag = true;  Variant called_on;  if (ar->hasThis()) {    called_on = Variant(ar->getThis());  } else if (ar->hasClass()) {    // For static methods, give handler the name of called class    called_on = Variant(const_cast<StringData*>(ar->getClass()->name()));  }  Array intArgs =    CREATE_VECTOR5(ar->m_func->fullNameRef(),                   called_on,                   get_frame_args_with_ref(ar),                   h->asCArrRef()[1],                   ref(doneFlag));  Variant ret = vm_call_user_func(h->asCArrRef()[0], intArgs);  if (doneFlag.toBoolean()) {    Offset pcOff;    ActRec* outer = g_vmContext->getPrevVMState(ar, &pcOff);    assert(outer);    frame_free_locals_inl_no_hook<true>(ar, ar->m_func->numLocals());    Stack& stack = g_vmContext->getStack();    stack.top() = (Cell*)(ar + 1);    tvDup(ret.asTypedValue(), stack.allocTV());    g_vmContext->m_fp = outer;    g_vmContext->m_pc = outer->m_func->unit()->at(pcOff);    return false;  }  g_vmContext->m_fp = ar;  g_vmContext->m_pc = savePc;  return true;}

 static void recv_cb(uv_udp_ext_t* udp_handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned int flags) {     auto* data = Native::data<UVUdpData>(udp_handle->udp_object_data);     auto recvCallback = data->recvCallback;     auto errorCallback = data->errorCallback;     if(nread > 0){         if(!recvCallback.isNull()){             vm_call_user_func(recvCallback,                  make_packed_array(                     udp_handle->udp_object_data,                     sock_addr((struct sockaddr *) addr),                     sock_port((struct sockaddr *) addr),                     String(buf->base, nread, CopyString),                     (int64_t) flags                 )             );         }     }     else{         if(!errorCallback.isNull()){             vm_call_user_func(errorCallback, make_packed_array(udp_handle->udp_object_data, nread, (int64_t) flags));         }     }     delete buf->base; }

Variant f_iterator_apply(const Variant& obj, const Variant& func,                         const Array& params /* = null_array */) {  CHECK_TRAVERSABLE_IMPL(obj, 0);  Object pobj = get_traversable_object_iterator(obj);  pobj->o_invoke_few_args(s_rewind, 0);  int64_t count = 0;  while (same(pobj->o_invoke_few_args(s_valid, 0), true)) {    if (!same(vm_call_user_func(func, params), true)) {      break;    }    ++count;    pobj->o_invoke_few_args(s_next, 0);  }  return count;}

 Variant do_callback(CVarRef cb, CArrRef args) {   assert(!m_exception);   try {     return vm_call_user_func(cb, args);   } catch (Object &e) {     ObjectData *od = e.get();     od->incRefCount();     m_exception = od;     m_phpException = true;   } catch (Exception &e) {     m_exception = e.clone();     m_phpException = false;   }   return uninit_null(); }

bool EventHook::RunInterceptHandler(ActRec* ar) {  const Func* func = ar->m_func;  if (LIKELY(func->maybeIntercepted() == 0)) return true;  Variant *h = get_intercept_handler(func->fullNameRef(),                                     &func->maybeIntercepted());  if (!h) return true;  Transl::VMRegAnchor _;  PC savePc = g_vmContext->m_pc;  Offset pcOff;  ActRec* outer = g_vmContext->getPrevVMState(ar, &pcOff);  assert(outer);  g_vmContext->m_fp = outer;  g_vmContext->m_pc = outer->m_func->unit()->at(pcOff);  try {    Variant doneFlag = true;    Variant obj = ar->hasThis() ?      Variant(Object(ar->getThis())) : uninit_null();    Array intArgs =      CREATE_VECTOR5(ar->m_func->fullNameRef(),                     obj,                     get_frame_args_with_ref(ar),                     h->asCArrRef()[1],                     ref(doneFlag));    Variant ret = vm_call_user_func(h->asCArrRef()[0], intArgs);    if (doneFlag.toBoolean()) {      frame_free_locals_inl_no_hook(ar, ar->m_func->numLocals());      Stack& stack = g_vmContext->getStack();      stack.top() = (Cell*)(ar + 1);      tvDup(ret.asTypedValue(), stack.allocTV());      return false;    }    g_vmContext->m_fp = ar;    g_vmContext->m_pc = savePc;  } catch (...) {    g_vmContext->m_fp = ar;    g_vmContext->m_pc = savePc;    g_vmContext->m_stack.top() = Stack::frameStackBase(ar);    throw;  }  return true;}

 static void send_cb(uv_udp_send_t* sr, int status) {     send_req_t *req = (send_req_t *) sr;     uv_udp_ext_t *udp_handle = (uv_udp_ext_t *) req->handle;     auto* data = Native::data<UVUdpData>(udp_handle->udp_object_data);     auto callback = data->sendCallback;     if(!callback.isNull()){         vm_call_user_func(callback,              make_packed_array(                 udp_handle->udp_object_data,                 sock_addr((struct sockaddr *) &req->addr),                 sock_port((struct sockaddr *) &req->addr),                 status             )         );             }     delete req->buf.base;     delete req; }

void EventHook::RunUserProfiler(const ActRec* ar, int mode) {  // Don't do anything if we are running the profiling function itself  // or if we haven't set up a profiler.  if (g_vmContext->m_executingSetprofileCallback ||      g_vmContext->m_setprofileCallback.isNull()) {    return;  }  // Don't profile 86ctor, since its an implementation detail,  // and we dont guarantee to call it  if (ar->m_func->cls() && ar->m_func == ar->m_func->cls()->getCtor() &&      Func::isSpecial(ar->m_func->name())) {    return;  }  Transl::VMRegAnchor _;  ExecutingSetprofileCallbackGuard guard;  Array params;  Array frameinfo;  if (mode == ProfileEnter) {    params.append(s_enter);    frameinfo.set(s_args, hhvm_get_frame_args(ar));  } else {    params.append(s_exit);    if (!g_vmContext->m_faults.empty()) {      Fault fault = g_vmContext->m_faults.back();      if (fault.m_faultType == Fault::Type::UserException) {        frameinfo.set(s_exception, fault.m_userException);      }    } else if (!ar->m_func->info() &&               !ar->m_func->isGenerator()) {      // TODO (#1131400) This is wrong for builtins      frameinfo.set(s_return, tvAsCVarRef(g_vmContext->m_stack.topTV()));    }  }  params.append(VarNR(ar->m_func->fullName()));  params.append(frameinfo);  vm_call_user_func(g_vmContext->m_setprofileCallback, params);}

static Variant xml_call_handler(const req::ptr<XmlParser>& parser,                                const Variant& handler,                                const Array& args) {  if (parser && handler.toBoolean()) {    Variant retval;    if (handler.isString() && !name_contains_class(handler.toString())) {      if (!parser->object.isObject()) {        retval = invoke(handler.toString().c_str(), args, -1);      } else {        retval = parser->object.toObject()->          o_invoke(handler.toString(), args);      }    } else if (is_callable(handler)) {      vm_call_user_func(handler, args);    } else {      raise_warning("Handler is invalid");    }    return retval;  }  return init_null();}

static Variant xml_call_handler(XmlParser *parser, CVarRef handler,                                CArrRef args) {  if (parser && handler) {    Variant retval;    if (handler.isString()) {      if (!parser->object.isObject()) {        retval = invoke(handler.toString().c_str(), args, -1);      } else {        retval = parser->object.toObject()->          o_invoke(handler.toString(), args);      }    } else if (handler.isArray() && handler.getArrayData()->size() == 2 &&               (handler[0].isString() || handler[0].isObject()) &&               handler[1].isString()) {      vm_call_user_func(handler, args);    } else {      raise_warning("Handler is invalid");    }    return retval;  }  return uninit_null();}

static void sqlite3_do_callback(sqlite3_context *context,                                const Variant& callback,                                int argc,                                sqlite3_value **argv,                                bool is_agg) {  Array params = Array::Create();  php_sqlite3_agg_context *agg_context = nullptr;  if (is_agg) {    agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context      (context, sizeof(php_sqlite3_agg_context));    params.appendRef(agg_context->context);    params.append(agg_context->row_count);  }  for (int i = 0; i < argc; i++) {    params.append(get_value(argv[i]));  }  Variant ret = vm_call_user_func(callback, params);  if (!is_agg || !argv) {    /* only set the sqlite return value if we are a scalar function,     * or if we are finalizing an aggregate */    if (ret.isInteger()) {      sqlite3_result_int(context, ret.toInt64());    } else if (ret.isNull()) {      sqlite3_result_null(context);    } else if (ret.isDouble()) {      sqlite3_result_double(context, ret.toDouble());    } else {      String sret = ret.toString();      sqlite3_result_text(context, sret.data(), sret.size(), SQLITE_TRANSIENT);    }  } else {    /* we're stepping in an aggregate; the return value goes into     * the context */    agg_context->context = ret;  }}

Variant f_xbox_process_call_message(const String& msg) {  Variant v = unserialize_from_string(msg);  if (!v.isArray()) {    raise_error("Error decoding xbox call message");  }  Array arr = v.toArray();  if (arr.size() != 2 || !arr.exists(0) || !arr.exists(1)) {    raise_error("Error decoding xbox call message");  }  Variant fn = arr.rvalAt(0);  if (fn.isArray()) {    Array farr = fn.toArray();    if (!array_is_valid_callback(farr)) {      raise_error("Error decoding xbox call message");    }  } else if (!fn.isString()) {    raise_error("Error decoding xbox call message");  }  Variant args = arr.rvalAt(1);  if (!args.isArray()) {    raise_error("Error decoding xbox call message");  }  return vm_call_user_func(fn, args.toArray());}

static Variant xml_call_handler(const req::ptr<XmlParser>& parser,                                const Variant& handler,                                const Array& args) {  if (parser && handler.toBoolean()) {    Variant retval;    if (handler.isString()) {      if (!parser->object.isObject()) {        retval = invoke(handler.toString().c_str(), args, -1);      } else {        retval = parser->object.toObject()->          o_invoke(handler.toString(), args);      }    } else if (handler.isArray() && handler.getArrayData()->size() == 2 &&               (handler.toCArrRef()[0].isString() ||                handler.toCArrRef()[0].isObject()) &&               handler.toCArrRef()[1].isString()) {      vm_call_user_func(handler, args);    } else {      raise_warning("Handler is invalid");    }    return retval;  }  return init_null();}

 static void idle_handle_callback(uv_idle_ext_t *idle_handle) {     auto* data = Native::data<UVNativeData>(idle_handle->idle_object_data);     vm_call_user_func(data->callback, make_packed_array(idle_handle->idle_object_data)); }

void heapgraphCallback(Array fields, const Variant& callback) {  VMRegAnchor _;  Array params;  params.append(fields);  vm_call_user_func(callback, params);}

size_t check_request_surprise() {  auto& info = TI();  auto& p = info.m_reqInjectionData;  auto const flags = fetchAndClearSurpriseFlags();  auto const do_timedout = (flags & TimedOutFlag) && !p.getDebuggerAttached();  auto const do_memExceeded = flags & MemExceededFlag;  auto const do_memThreshold = flags & MemThresholdFlag;  auto const do_signaled = flags & SignaledFlag;  auto const do_cpuTimedOut =    (flags & CPUTimedOutFlag) && !p.getDebuggerAttached();  auto const do_GC = flags & PendingGCFlag;  // Start with any pending exception that might be on the thread.  auto pendingException = info.m_pendingException;  info.m_pendingException = nullptr;  if (do_timedout) {    p.setCPUTimeout(0);  // Stop CPU timer so we won't time out twice.    if (pendingException) {      setSurpriseFlag(TimedOutFlag);    } else {      pendingException = generate_request_timeout_exception();    }  }  // Don't bother with the CPU timeout if we're already handling a wall timeout.  if (do_cpuTimedOut && !do_timedout) {    p.setTimeout(0);  // Stop wall timer so we won't time out twice.    if (pendingException) {      setSurpriseFlag(CPUTimedOutFlag);    } else {      pendingException = generate_request_cpu_timeout_exception();    }  }  if (do_memExceeded) {    if (pendingException) {      setSurpriseFlag(MemExceededFlag);    } else {      pendingException = generate_memory_exceeded_exception();    }  }  if (do_memThreshold) {    clearSurpriseFlag(MemThresholdFlag);    if (!g_context->m_memThresholdCallback.isNull()) {      VMRegAnchor _;      try {        vm_call_user_func(g_context->m_memThresholdCallback, empty_array());      } catch (Object& ex) {        raise_error("Uncaught exception escaping mem Threshold callback: %s",                    ex.toString().data());      }    }  }  if (do_GC) {    VMRegAnchor _;    if (RuntimeOption::EvalEnableGC) {      MM().collect("surprise");    } else {      MM().checkHeap("surprise");    }  }  if (do_signaled) {    HHVM_FN(pcntl_signal_dispatch)();  }  if (pendingException) {    pendingException->throwException();  }  return flags;}

 static void event_http_request_cb(evhttp_request_t *request, void *data) {     EventHttpRequestResourceData *resource_data = (EventHttpRequestResourceData *) data;     evhttp_request_own((evhttp_request_t *) resource_data->getInternalResourceData());     vm_call_user_func(Object(resource_data->getCallback()), make_packed_array(Object(resource_data->getObjectData()), resource_data->getCallbackArg())); }

static int cmp_func(CVarRef v1, CVarRef v2, const void *data) {  Variant *callback = (Variant *)data;  return vm_call_user_func(*callback, make_packed_array(v1, v2)).toInt32();}

//.........这里部分代码省略.........  Array args;  // Reverse order to pop values off ctxt stack  for (int i = nargs - 2; i >= 0; i--) {    Variant arg;    obj = valuePop(ctxt);    switch (obj->type) {    case XPATH_STRING:      arg = String((char*)obj->stringval, CopyString);      break;    case XPATH_BOOLEAN:      arg = (bool)obj->boolval;      break;    case XPATH_NUMBER:      arg = (double)obj->floatval;      break;    case XPATH_NODESET:      if (type == 1) {        char *str = (char*)xmlXPathCastToString(obj);        arg = String(str, CopyString);        xmlFree(str);      } else if (type == 2) {        arg = Array::Create();        if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {          for (int j = 0; j < obj->nodesetval->nodeNr; j++) {            // TODO: not sure this is the right thing to do.            xmlNodePtr node = obj->nodesetval->nodeTab[j];            if (node->type == XML_ELEMENT_NODE) {              Object element = newNode(s_DOMElement,                                       xmlCopyNode(node, /*extended*/ 1));              arg.toArrRef().append(element);            } else if (node->type == XML_ATTRIBUTE_NODE) {              Object attribute =                newNode(s_DOMAttr,                        (xmlNodePtr)xmlCopyProp(nullptr, (xmlAttrPtr)node));              arg.toArrRef().append(attribute);            } else if (node->type == XML_TEXT_NODE) {              Object text =                newNode(s_DOMText,                        (xmlNodePtr)xmlNewText(xmlNodeGetContent(node)));              arg.toArrRef().append(text);            } else {              raise_warning("Unhandled node type '%d'", node->type);              // Use a generic DOMNode as fallback for now.              Object nodeobj = newNode(s_DOMNode,                                       xmlCopyNode(node, /*extended*/ 1));              arg.toArrRef().append(nodeobj);            }          }        }      }      break;    default:      arg = String((char*)xmlXPathCastToString(obj), CopyString);    }    xmlXPathFreeObject(obj);    args.prepend(arg);  }  obj = valuePop(ctxt);  if (obj->stringval == nullptr) {    raise_warning("Handler name must be a string");    xmlXPathFreeObject(obj);    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));    return;  }  String handler((char*)obj->stringval, CopyString);  xmlXPathFreeObject(obj);  if (!HHVM_FN(is_callable)(handler)) {    raise_warning("Unable to call handler %s()", handler.data());    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));  } else if (intern->m_registerPhpFunctions == 2 &&             !intern->m_registered_phpfunctions.exists(handler)) {    raise_warning("Not allowed to call handler '%s()'", handler.data());    // Push an empty string to get an xslt result.    valuePush(ctxt, xmlXPathNewString((xmlChar*)""));  } else {    Variant retval = vm_call_user_func(handler, args);    if (retval.isObject() &&        retval.getObjectData()->instanceof(s_DOMNode)) {      ObjectData *retval_data = retval.asCObjRef().get();      xmlNode* nodep = Native::data<DOMNode>(retval_data)->nodep();      valuePush(ctxt, xmlXPathNewNodeSet(nodep));      intern->m_usedElements.prepend(retval);    } else if (retval.is(KindOfBoolean)) {      valuePush(ctxt, xmlXPathNewBoolean(retval.toBoolean()));    } else if (retval.isObject()) {      raise_warning("A PHP Object cannot be converted to an XPath-string");      // Push an empty string to get an xslt result.      valuePush(ctxt, xmlXPathNewString((xmlChar*)""));    } else {      String sretval = retval.toString();      valuePush(ctxt, xmlXPathNewString((xmlChar*)sretval.data()));    }  }}

 static void event_http_default_cb(evhttp_request_t *request, void *data) {     EventHttpResourceData *resource_data = (EventHttpResourceData *) data;     vm_call_user_func(Object(resource_data->getDefaultCallback()), make_packed_array(makeEventHttpRequestObject(request), resource_data->getDefaultCallbackArg())); }

static int cmp_func(CVarRef v1, CVarRef v2, const void *data) {  Variant *callback = (Variant *)data;  return vm_call_user_func(*callback, CREATE_VECTOR2(v1, v2)).toInt32();}

 void requestInit() override {   vm_call_user_func(s_default_filters_register_func, empty_array_ref); }

bool EventHook::RunInterceptHandler(ActRec* ar) {  const Func* func = ar->func();  if (LIKELY(func->maybeIntercepted() == 0)) return true;  // Intercept only original generator / async function calls, not resumption.  if (ar->resumed()) return true;  Variant* h = get_intercept_handler(func->fullNameStr(),                                     &func->maybeIntercepted());  if (!h) return true;  /*   * In production mode, only functions that we have assumed can be   * intercepted during static analysis should actually be   * intercepted.   */  if (RuntimeOption::RepoAuthoritative &&      !RuntimeOption::EvalJitEnableRenameFunction) {    if (!(func->attrs() & AttrInterceptable)) {      raise_error("fb_intercept was used on a non-interceptable function (%s) "                  "in RepoAuthoritative mode", func->fullName()->data());    }  }  VMRegAnchor _;  PC savePc = vmpc();  Variant doneFlag = true;  Variant called_on;  if (ar->hasThis()) {    called_on = Variant(ar->getThis());  } else if (ar->hasClass()) {    // For static methods, give handler the name of called class    called_on = Variant(const_cast<StringData*>(ar->getClass()->name()));  }  Variant intArgs =    PackedArrayInit(5)      .append(VarNR(ar->func()->fullName()))      .append(called_on)      .append(get_frame_args_with_ref(ar))      .append(h->asCArrRef()[1])      .appendRef(doneFlag)      .toArray();  Variant ret = vm_call_user_func(h->asCArrRef()[0], intArgs);  if (doneFlag.toBoolean()) {    Offset pcOff;    ActRec* outer = g_context->getPrevVMState(ar, &pcOff);    frame_free_locals_inl_no_hook<true>(ar, ar->func()->numLocals());    Stack& stack = vmStack();    stack.top() = (Cell*)(ar + 1);    cellDup(*ret.asCell(), *stack.allocTV());    vmfp() = outer;    vmpc() = outer ? outer->func()->unit()->at(pcOff) : nullptr;    return false;  }  vmfp() = ar;  vmpc() = savePc;  return true;}

 virtual void requestInit() {   vm_call_user_func(s_default_filters_register_func, empty_array_ref); }