Lines Matching defs:function
52 #include "src/wasm/function-body-decoder-impl.h"
53 #include "src/wasm/function-compiler.h"
241 // at least two places, put a helper function here.
564 // the WasmIsValidRefValue runtime function.
811 // The function-prologue stack check is associated with position 0, which
812 // is never a position of any instruction in the function.
813 // We pass the null instance cache, as we are at the beginning of the function
1473 // function.
1476 // to generate a call to a testing c-function instead of a runtime
2228 Node* function = gasm_->ExternalConstant(ref);
2230 return BuildCCall(&sig, function, stack_slot_param);
2332 // We do truncation by calling a C function which calculates the result.
2333 // The input is passed to the C function as a byte buffer holding the two
2336 // function, and after calling the C function we collect the return value from
2348 Node* function = gasm_->ExternalConstant(ref);
2349 BuildCCall(&sig, function, stack_slot);
2391 Node* function = gasm_->ExternalConstant(ref);
2392 BuildCCall(&sig, function, stack_slot);
2434 Node* function = gasm_->ExternalConstant(call_ref);
2435 Node* overflow = BuildCCall(&sig, function, stack_slot);
2964 Node* function = gasm_->ExternalConstant(ref);
2965 Node* call = BuildCCall(&sig, function, stack_slot);
2977 Node* WasmGraphBuilder::BuildCCall(MachineSignature* sig, Node* function,
2981 Node* call_args[] = {function, args..., effect(), control()};
3089 // Load the imported function refs array from the instance.
3123 // Call to an imported function.
3128 // A direct call to a wasm function defined in this module.
3129 // Just encode the function index. This will be patched at instantiation.
3216 // Check that the table entry is not null and that the type of the function is
3217 // **identical with** the function type declared at the call site (no
3221 // TODO(9495): Change this if we should do full function subtyping instead.
3282 Node* function) {
3284 MachineType::TaggedPointer(), function,
3290 // TODO(9495): Support CAPI function refs.
3301 Node* function = args[0];
3307 MachineType::TaggedPointer(), function,
3311 function, WasmInternalFunction::kForeignAddressOffset);
3318 MachineType::TaggedPointer(), function,
3347 // Since we are comparing to a function reference, it is guaranteed that
3384 // Return Call to an imported function.
3388 // A direct tail call to a wasm function defined in this module.
3389 // Just encode the function index. This will be patched during code
3648 // Only call this function for code which is not reused across instantiations,
5420 Node* function =
5435 Node* call = BuildCCall(&sig, function, stack_slot);
5495 Node* function =
5508 Node* call = BuildCCall(&sig, function, stack_slot);
5514 Node* function =
5527 Node* call = BuildCCall(&sig, function, stack_slot);
5845 Node** no_match_effect, std::function<void(Callbacks)> type_checker) {
6126 Node* function =
6133 BuildCCall(&sig, function, GetInstance(), dst_array, dst_index, src_array,
6439 // Extract external function if this is a WasmInternalFunction.
6445 auto function = gasm_->MakeLabel();
6451 &function);
6458 gasm_->Bind(&function);
6470 // Typed function. Extract the external function.
6503 // If {input} is a function, returns the WasmInternalFunction associated with
6818 // Call to an imported function.
6819 // Load function index from {WasmExportedFunctionData}.
6825 // Call to a wasm function defined in this module.
6826 // The (cached) call target is the jump table slot for that function.
6947 // function (passed as a parameter), such that the generated code is
6957 // Check whether the signature of the function allows for a fast
7029 // Check function strict bit.
7214 // TypeError, if the target is a native function, or if the target is a
7305 Node* function = BuildLoadCallTargetFromExportedFunctionData(sfi_data);
7312 BuildCCall(&host_sig, function, host_data_foreign, values);
7734 ", reason: the signature of the imported function in the Wasm "
7735 "module doesn't match that of the Fast API function]\n");
7741 // Here and below, we log when the function we call is declared as an Api
7742 // function but we cannot optimize the call, which might be unxepected. In
7863 Handle<JSFunction> function = Handle<JSFunction>::cast(callable);
7864 Handle<SharedFunctionInfo> shared(function->shared(),
7865 function->GetIsolate());
7928 // If function isn't compiled, compile it now.
7932 Compiler::Compile(isolate, function, Compiler::CLEAR_EXCEPTION,
7989 // Compile a Wasm function with a single bytecode and let TurboFan
8424 int name_len = SNPrintF(name_vector, "wasm-function#%d", index);
8438 // Check that we do not accidentally compile a Wasm function to TurboFan if
8510 // If we tiered up only one function for debugging, dump statistics