Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
129 // - Code
537 // code for the class including allocation and garbage collection routines,
1011 V(Code) \
1089 V(kCodeGenerationFailed, "code generation failed") \
1090 V(kCodeObjectNotProperlyPatched, "code object not properly patched") \
1131 V(kGeneratedCodeIsTooLarge, "Generated code is too large") \
1488 // Returns the permanent hash code associated with this object depending on
1602 // RuntimeStubs assumes EXCEPTION = 1 in the compiler-generated code.
1754 // from code that allocates and thus invalidates the returned write
2021 // Retrieves a permanent object identity hash code. The undefined value might
2064 // be quickly accessed. This fact is used in the generated code. The
2590 Handle<Code> code);
2592 MUST_USE_RESULT MaybeObject* UpdateMapCodeCache(Name* name, Code* code);
2885 // common accessors and some code paths.
2950 // Code Generation support.
3033 // Code Generation support.
3519 // To scale a computed hash code to fit within the hash table, we
4057 // Return the number of stack slots for code. This number consists of two
4063 // Return the number of context slots for code if a context is allocated. This
4256 // that is attached to code objects.
4593 // data for code generated by the Hydrogen/Lithium compiler. It also
4684 // data for code generated by the full compiler.
4725 // cache cells and AST ids for code generated by the full compiler.
4769 // Code describes objects with on-the-fly generated machine code.
4770 class Code: public HeapObject {
4772 // Opaque data type for encapsulating code flags like kind, inline
4847 // [relocation_info]: Code relocation information
4858 // unoptimized code. Optimized code can temporarily store the head of
4859 // the list of code to be deoptimized during mark-compact GC.
4868 // Used during GC to code a list of code objects to deoptimize.
4893 // [flags]: Various code flags.
4897 // [flags]: Access to specific code flags.
4932 // For kind STUB or ICs, tells whether or not a code object was generated by
4969 // the code object was seen on the stack with no IC patching going on.
4974 // reserved in the code prologue.
5006 // the code is going to be deoptimized because of dead embedded maps.
5024 // Find the first code in an IC stub.
5025 Code* FindFirstCode();
5085 // Convert a target address into a code object.
5086 static inline Code* GetCodeFromTargetAddress(Address address);
5103 // Code entry point.
5109 // Relocate the code by delta bytes. Called to signal that this code
5113 // Migrate code described by desc.
5122 // Calculate the size of the code object to report for log events. This takes
5123 // the layout of the code object into account.
5125 // Check that the assumptions about the layout of the code object holds.
5127 Code::kHeaderSize);
5128 return instruction_size() + Code::kHeaderSize;
5136 static inline Code* cast(Object* obj);
5145 DECLARE_PRINTER(Code)
5146 DECLARE_VERIFIER(Code)
5161 // Code aging. Indicates how many full GCs this code has survived without
5163 // relatively safe to flush this code object and replace it with the lazy
5203 // the Code object header.
5287 PlatformSmiTagging::kSmiValueSize - Code::kArgumentsCountShift + 1;
5304 // Code aging
5306 static void GetCodeAgeAndParity(Code* code, Age* age,
5310 static Code* GetCodeAgeStub(Age age, MarkingParity parity);
5312 // Code aging -- platform-specific
5316 DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
5332 // in the corresponding group. The subsequent elements contain grouped code
5335 // code objects within a group is not preserved.
5337 // All code indexes used in the class are counted starting from the first
5338 // code object of the first group. In other words, code index 0 corresponds
5344 // Group of code that weakly embed this map and depend on being
5347 // Group of code that embed a transition to this map, and depend on being
5350 // Group of code that omit run-time prototype checks for prototypes
5353 // possibly invalidating the assumptions embedded in the code.
5355 // Group of code that depends on elements not being added to objects with
5358 // Group of code that depends on global property values in property cells
5364 // Array for holding the index of the first code object of each group.
5365 // The last element stores the total number of code objects.
5376 bool Contains(DependencyGroup group, Code* code);
5382 Code* code);
5394 inline Code* code_at(int i);
5408 // code objects of the subsequent groups.
5654 // Returns true if map has a non-empty stub code cache.
5670 // [dependent code]: list of optimized codes that have this map embedded.
5843 // Code cache operations.
5845 // Clears the code cache.
5848 // Update code cache.
5851 Handle<Code> code);
5852 MUST_USE_RESULT MaybeObject* UpdateCodeCache(Name* name, Code* code);
5861 // Returns the found code or undefined if absent.
5862 Object* FindInCodeCache(Name* name, Code::Flags flags);
5864 // Returns the non-negative index of the code object if it is in the
5866 int IndexInCodeCache(Object* name, Code* code);
5868 // Removes a code object from the code cache at the given index.
5869 void RemoveFromCodeCache(Name* name, Code* code, int index);
5925 Handle<Code> code);
5982 // Layout of pointer fields. Heap iteration code relies on them
6136 // [eval_from_instructions_offset]: the instruction offset in the code for the
6196 // List of builtin functions we want to identify to improve code
6254 // [code]: Function code.
6255 DECL_ACCESSORS(code, Code)
6256 inline void ReplaceCode(Code* code);
6258 // [optimized_code_map]: Map from native context to optimized code
6263 // i - 1 is the context, position i the code, and i + 1 the literals array.
6267 // Installs optimized code from the code map on the given closure. The
6271 // Clear optimized code map.
6274 // Removed a specific optimized code object from the optimized code map.
6275 void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);
6277 // Trims the optimized code map after entries have been removed.
6280 // Add a new entry to the optimized code map.
6282 Code* code,
6286 Handle<Code> code,
6289 // Layout description of the optimized code map.
6301 // [construct stub]: Code stub for constructing instances of this function.
6302 DECL_ACCESSORS(construct_stub, Code)
6304 // Returns if this function has been compiled to native code yet.
6316 // Set the formal parameter count so the function code will be
6404 // Also clears the optimized code map.
6443 // [start_position_and_type]: Field used to store both the source code
6447 // expression and the rest contains the source code position.
6456 // profiling of JavaScript code written in OO style, where almost
6476 // Is this function a function expression in the source code.
6498 // This is used to determine if we can safely flush code from a function
6514 // Indicates the language mode of the function's code as defined by the
6555 // Is this a function or top-level/eval code.
6564 // Indicates that code for this function cannot be cached.
6567 // Indicates that code for this function cannot be flushed.
6573 // Indicates whether or not the code in the shared function support
6577 // Enable deoptimization support through recompiled code.
6578 void EnableDeoptimizationSupport(Code* recompiled);
6585 // code, returns whether it asserted (i.e., always true if assertions are
6589 // [source code]: Source code for the function.
6630 // Helper to compile the shared code. Returns true on success, false on
6741 // The source code start position is in the 30 most significant bits of
6839 // [continuation]: Offset into code of continuation.
6935 // [code]: The generated code object for this function. Executed
6939 inline Code* code();
6940 inline void set_code(Code* code);
6941 inline void set_code_no_write_barrier(Code* code);
6942 inline void ReplaceCode(Code* code);
7042 // Returns if this function has been compiled to native code yet.
7058 // Iterates the objects, including code objects indirectly referenced
7059 // through pointers to the first instruction in the code object.
7207 // Accessors for code of the runtime routines written in JavaScript.
7208 inline Code* javascript_builtin_code(Builtins::JavaScript id);
7209 inline void set_javascript_builtin_code(Builtins::JavaScript id, Code* value);
7220 // (function and code object).
7361 // prevent leaking information to user code called during error
7421 // - a reference to code for ASCII inputs (bytecode or compiled), or a smi
7422 // used for tracking the last usage (used for code flushing).
7423 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
7424 // used for tracking the last usage (used for code flushing)..
7433 // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
7494 // Irregexp compiled code or bytecode for ASCII. If compilation
7498 // Irregexp compiled code or bytecode for UC16. If compilation
7503 // Saved instance of Irregexp compiled code or bytecode for ASCII that
7506 // Saved instance of Irregexp compiled code or bytecode for UC16 that is
7536 // The uninitialized value for a regexp code object.
7539 // The compilation error value for the regexp code object. The real error
7540 // object is in the saved code field.
7543 // When we store the sweep generation at which we moved the code from the
7544 // code index to the saved code index we mask it of to be in the [0:255]
7610 // Add the code object to the cache.
7611 MUST_USE_RESULT MaybeObject* Update(Name* name, Code* code);
7613 // Lookup code object in the cache. Returns code object if found and undefined
7615 Object* Lookup(Name* name, Code::Flags flags);
7617 // Get the internal index of a code object in the cache. Returns -1 if the
7618 // code object is not in that cache. This index can be used to later call
7621 int GetIndex(Object* name, Code* code);
7624 void RemoveByIndex(Object* name, Code* code, int index);
7638 MUST_USE_RESULT MaybeObject* UpdateDefaultCache(Name* name, Code* code);
7639 MUST_USE_RESULT MaybeObject* UpdateNormalTypeCache(Name* name, Code* code);
7640 Object* LookupDefaultCache(Name* name, Code::Flags flags);
7641 Object* LookupNormalTypeCache(Name* name, Code::Flags flags);
7643 // Code cache layout of the default cache. Elements are alternating name and
7644 // code objects for non normal load/store/call IC's.
7680 Object* Lookup(Name* name, Code::Flags flags);
7681 MUST_USE_RESULT MaybeObject* Put(Name* name, Code* code);
7683 int GetIndex(Name* name, Code::Flags flags);
7702 Code::Flags flags,
7703 Handle<Code> code);
7706 Code::Flags flags,
7707 Code* code);
7710 Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
7733 Code* code);
7966 // concrete performance benefit at that particular point in the code.
8013 // Tells whether the hash code has been computed.
8034 // Mask constant for checking if a name has a computed hash code
8036 // indicates whether a hash code has been computed. If the hash code has
8043 // Shift constant retrieving hash code from hash field.
8433 // Compute and set the hash code.
8513 // For regexp code.
8728 // For regexp code.
8971 // [dependent_code]: dependent code that depends on the type of the global
8977 // a change of the type of the cell's contents, code dependent on the cell
9008 void AddDependentCode(Handle<Code> code);
9025 // [hash]: The hash code property (undefined if not initialized yet).
9948 // Code object for the original code.
9949 DECL_ACCESSORS(original_code, Code)
9950 // Code object for the patched code. This code object is the code object
9952 DECL_ACCESSORS(code, Code)
9956 // Check if there is a break point at a code position.
9958 // Get the break point info object for a code position.
9968 // Get the break point objects for a code position.
9994 // Lookup the index in the break_points array for a code position.
10002 // function. The DebugInfo object holds a BreakPointInfo object for each code
10006 // The position in the code for the break point.
10025 // Get the number of break points for this code position.
10093 // a rich interface for iterating over Code objects..
10095 // Visits a code target in the instruction stream.
10098 // Visits a code entry in a JS function.
10117 // about the code's age.
10123 // Visit pointer embedded into a code object.
