Lines Matching refs:Function
2169 // a (possibly inlined) function.
2183 // State for an inline function.
2454 Bailout("function with illegal redeclaration");
2458 Bailout("function calls eval");
2484 // Handle implicit declaration of the function name in named function
2486 if (scope->is_function_scope() && scope->function() != NULL) {
2487 HandleDeclaration(scope->function(), CONST, NULL, NULL);
2496 VisitStatements(info()->function()->body());
2884 // Return from an inlined function, visit the subexpression in the
4234 // Bail out if we try to mutate a parameter value in a function
4236 // arguments property of the function.
4245 "assignment to parameter, function uses arguments object");
4428 // Bail out if we try to mutate a parameter value in a function using
4430 // arguments property of the function.
4562 Handle<JSFunction> function(lookup.GetConstantFunctionFromMap(*map));
4563 return new(zone()) HConstant(function, Representation::Tagged());
4947 Bailout("arguments access in inlined function");
5009 HValue* function = Pop();
5010 AddInstruction(new(zone()) HCheckNonSmi(function));
5011 instr = new(zone()) HLoadFunctionPrototype(function);
5263 // Parse or scope error, never optimize this function.
5275 FunctionLiteral* function = target_info.function();
5279 nodes_added = function->ast_node_count();
5285 AstProperties::Flags* flags(function->flags());
5291 // If the function uses the arguments object check that inlining of functions
5294 if (function->scope()->arguments() != NULL) {
5300 if (!function->scope()->arguments()->IsStackAllocated()) {
5319 // the target function if we don't already have it.
5330 // function is inlined before being called for the first time.
5342 // After this point, we've made a decision to inline this function (so
5346 // for the inlined function.
5352 // The function state is new-allocated because we need to delete it
5361 function,
5370 // can remove the unsightly ifdefs in this function.
5380 function,
5383 function->scope()->arguments()));
5384 // If the function uses arguments object create and bind one.
5385 if (function->scope()->arguments() != NULL) {
5386 ASSERT(function->scope()->arguments()->IsStackAllocated());
5387 environment()->Bind(function->scope()->arguments(),
5391 VisitStatements(function->body());
5393 // Bail out if the inline function did, as we cannot residualize a call
5432 // Fix up the function exits.
5468 // The function call we are inlining is a method call if the call
5513 if (drop_extra) Drop(1); // Optionally drop the function.
5531 // Try to inline calls like Math.* as operations in the calling function.
5751 HValue* function = Top();
5752 AddCheckConstantFunction(expr, function, function_map, true);
5764 AddInstruction(new(zone()) HWrapReceiver(receiver, function));
5766 new(zone()) HApplyArguments(function,
5774 // We are inside inlined function and we know exactly what is inside
5779 AddInstruction(new(zone()) HWrapReceiver(receiver, function));
5791 function,
5812 // Keyed function call.
5831 // Named function call.
5901 // access check is not enabled we assume that the function will not change
5902 // and generate optimized code for calling the function.
5919 HValue* function = Pop();
5920 AddInstruction(new(zone()) HCheckFunction(function, expr->target()));
5955 // The function is on the stack in the unoptimized code during
5958 HValue* function = Top();
5965 AddInstruction(new(zone()) HCheckFunction(function, expr->target()));
5967 if (TryInlineBuiltinFunctionCall(expr, true)) { // Drop the function.
5976 if (TryInlineCall(expr, true)) { // Drop function from environment.
5980 function,
5982 Drop(1); // The function.
5987 HValue* function = Top();
5996 call = new(zone()) HCallFunction(context, function, argument_count);
6024 // The constructor function is on the stack in the unoptimized code
6027 HValue* function = Top();
6031 new(zone()) HCheckFunction(function, constructor));
6039 // Replace the constructor function with a newly allocated receiver.
6044 ASSERT(environment()->ExpressionStackAt(receiver_index) == function);
6055 environment()->SetExpressionStackAt(receiver_index, function);
6057 new(zone()) HCallNew(context, function, argument_count));
6061 // The constructor function is both an operand to the instruction and an
6095 return Bailout("call to a JavaScript runtime function");
6098 const Runtime::Function* function = expr->function();
6099 ASSERT(function != NULL);
6100 if (function->intrinsic_type == Runtime::INLINE) {
6103 // Call to an inline function.
6104 int lookup_index = static_cast<int>(function->function_id) -
6114 ASSERT(function->intrinsic_type == Runtime::RUNTIME);
6121 new(zone()) HCallRuntime(context, name, function, argument_count);
6361 // Bail out if we try to mutate a parameter value in a function
6363 // arguments property of the function.
6851 // Check to see if the rhs of the instanceof is a global function not
6852 // residing in new space. If it is we assume that the function will stay the
6868 // If the function is in new space we assume it's more likely to
6876 // If the target is not null we have found a known global function that is
7007 Handle<SharedFunctionInfo> function =
7010 if (function.is_null()) {
7014 array->set(j++, *function);
7032 FunctionLiteral* function,
7044 if (binding_needs_init || function != NULL) {
7046 if (function != NULL) {
7047 CHECK_ALIVE(VisitForValue(function));
7187 return Bailout("inlined runtime function: IsNonNegativeSmi");
7204 "inlined runtime function: IsStringWrapperSafeForDefaultValueOf");
7212 // We are generating graph for inlined function.
7228 // function is blacklisted by AstNode::IsInlineable.
7240 // function is blacklisted by AstNode::IsInlineable.
7257 return Bailout("inlined runtime function: ClassOf");
7452 return Bailout("inlined runtime function: GetFromCache");
7470 // 1 ~ The function to call is not itself an argument to the call.
7479 HValue* function = Pop();
7482 // Branch for function proxies, or other non-functions.
7484 new(zone()) HHasInstanceTypeAndBranch(function, JS_FUNCTION_TYPE);
7494 new(zone()) HInvokeFunction(context, function, arg_count));
7501 new(zone()) HCallFunction(context, function, arg_count));
7573 return Bailout("inlined runtime function: MathSqrt");
7579 return Bailout("inlined runtime function: IsRegExpEquivalent");
7593 return Bailout("inlined runtime function: FastAsciiArrayJoin");
7792 FunctionLiteral* function,
7801 int arity = function->scope()->num_parameters();
7809 // actually be the constructor function, but we pass the newly allocated
7820 new(zone) HEnvironment(outer, function->scope(), target);
7827 // If the function we are inlining is a strict mode function or a
7828 // builtin function, pass undefined as the receiver for function
7830 if ((target->shared()->native() || !function->is_classic_mode()) &&
7873 void HTracer::TraceCompilation(FunctionLiteral* function) {
7875 Handle<String> name = function->debug_name();
