Lines Matching defs:code
2 // Use of this source code is governed by a BSD-style license that can be
9 #include "src/code-factory.h"
10 #include "src/code-stubs.h"
20 #include "src/arm/code-stubs-arm.h"
29 // A patch site is a location in the code which it is possible to patch. This
30 // class has a number of methods to emit the code which is patchable and the
31 // method EmitPatchInfo to record a marker back to the patchable code. This
34 // the patchable code.
48 // the inlined smi code.
58 // the inlined smi code.
79 __ nop(); // Signals no inlined code.
92 // Generate code for a JS function. On entry to the function the receiver
115 Comment cmnt(masm_, "[ function compiled by full code generator");
145 // MANUAL indicates that the scope shouldn't actually generate code to set up
310 Handle<Code> stack_check = isolate()->builtins()->StackCheck();
386 // Block literal pools whilst emitting back edge code.
399 // the AST id from the unoptimized code in order to use it as a key into
400 // the deoptimization input data found in the optimized code.
446 // Add a label for checking the size of the code used for returning.
455 // TODO(svenpanne) The code below is sometimes 4 words, sometimes 5!
467 // Check that the size of the code used for returning is large enough
697 Handle<Code> ic = ToBooleanStub::GetUninitialized(isolate());
763 // Emit the write barrier code if the location is in the heap.
1058 Handle<Code> ic =
1059 CodeFactory::CompareIC(isolate(), Token::EQ_STRICT).code();
1142 // Check cache validity in generated code. This is a fast case for
1211 // Generate code for doing the condition check.
1259 // Generate code for the body of the loop.
1262 // Generate code for the going to the next element by incrementing
1310 // Generate code for the body of the loop.
1327 // Use the fast case closure allocation code that allocates in new
1331 // we are creating here gets a chance to have its code optimized and
1332 // doesn't just get a copy of the existing unoptimized code.
1475 // Generate fast-case code for variables that might be shadowed by
1531 // var->scope() may be NULL when the proxy is located in eval code and
1541 // the same declaration scope (i.e. they are both in global code, in the
1542 // same function or in the same eval code) and the VariableProxy is in
1594 // Generate code for loading from variables potentially shadowed
1701 // marked expressions, no store code is emitted.
1769 // Emit code to define accessors, using only a single call to the runtime for
1839 // Emit code to evaluate all the non-constant subexpressions and to store
2115 Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
2136 Handle<Code> bool_ic = ToBooleanStub::GetUninitialized(isolate());
2227 // Load the new code object's constant pool pointer.
2229 MemOperand(r3, Code::kConstantPoolOffset - Code::kHeaderSize));
2351 Handle<Code> ic = CodeFactory::KeyedLoadIC(isolate()).code();
2384 Handle<Code> code = CodeFactory::BinaryOpIC(isolate(), op, mode).code();
2385 CallIC(code, expr->BinaryOperationFeedbackId());
2390 // Smi case. This code works the same way as the smi-smi case in the type
2460 Handle<Code> code = CodeFactory::BinaryOpIC(isolate(), op, mode).code();
2461 JumpPatchSite patch_site(masm_); // unbound, signals no inlined smi code.
2462 CallIC(code, expr->BinaryOperationFeedbackId());
2506 Handle<Code> ic =
2507 CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
2603 // Record source code position before IC call.
2618 // Record source code position before IC call.
2623 Handle<Code> ic = CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
2656 void FullCodeGenerator::CallIC(Handle<Code> code,
2659 // All calls must have a predictable size in full-codegen code to ensure that
2661 __ Call(code, RelocInfo::CODE_TARGET, ast_id, al,
2666 // Code common for calls using the IC.
2738 // Code common for calls using the IC.
2774 Handle<Code> ic = CallIC::initialize_stub(
2876 // Generate code for loading from variables potentially shadowed
2890 // If fast case code has been generated, emit code to push the
2892 // code.
2971 // Record call targets in unoptimized code.
3627 // overwritten by the write barrier code and is needed afterward.
4081 // Jump into the loop after the code that copies the separator, so the first
4449 Handle<Code> code =
4450 CodeFactory::BinaryOpIC(isolate(), Token::ADD, NO_OVERWRITE).code();
4451 CallIC(code, expr->CountBinOpFeedbackId());
4495 Handle<Code> ic =
4496 CodeFactory::KeyedStoreIC(isolate(), strict_mode()).code();
4533 // Generate code for loading from variables potentially shadowed
4686 Handle<Code> ic = CodeFactory::CompareIC(isolate(), op).code();
4721 Handle<Code> ic = CompareNilICStub::GetUninitialized(isolate(), nil);
4763 // code
4769 // code. Fetch it from the context.
4786 // Cook return address in link register to stack (smi encoded Code* delta)
4859 // code, we can restore it directly from there for the finally code
4923 void BackEdgeTable::PatchAt(Code* unoptimized_code,
4926 Code* replacement_code) {
4991 Code* unoptimized_code,
