Lines Matching defs:Code
2 // Use of this source code is governed by a BSD-style license that can be
119 // - Code
303 // ICs store extra state in a Code object. The default extra state is
508 // code for the class including allocation and garbage collection routines,
941 V(Code) \
1167 // Returns the permanent hash code associated with this object. May return
1171 // Returns the permanent hash code associated with this object depending on
1172 // the actual object type. May create and store a hash code if needed and none
1389 // Adds the |code| object related to |name| to the code cache of this map. If
1394 Handle<Code> code);
1401 // from code that allocates and thus invalidates the returned write
1435 // as above, for the next code link of a code object.
1624 // Retrieves a permanent object identity hash code. The undefined value might
1628 // Retrieves a permanent object identity hash code. May create and store a
1629 // hash code if needed and none exists.
1673 // be quickly accessed. This fact is used in the generated code. The
2150 // our heap verification code could stumble across it.
2374 // common accessors and some code paths.
2451 // Code Generation support.
2537 // Code Generation support.
2574 // [first_index(CODE_PTR, SMALL_SECTION)] : code pointer entries
2585 // [kExtendedCodePtrCountOffset] : count of extended code pointers
2590 // [first_index(CODE_PTR, EXTENDED_SECTION)]: code pointer entries
2713 // Setters which take a raw offset rather than an index (for code generation).
2788 // Code Generation support.
3319 // To scale a computed hash code to fit within the hash table, we
4017 // embedded in optimized code to dependent code lists.
4119 // Return the number of stack slots for code. This number consists of two
4125 // Return the number of context slots for code if a context is allocated. This
4345 // that is attached to code objects.
4785 // data for code generated by the Hydrogen/Lithium compiler. It also
4879 // data for code generated by the full compiler.
4921 // Code describes objects with on-the-fly generated machine code.
4922 class Code: public HeapObject {
4924 // Opaque data type for encapsulating code flags like kind, inline
4985 // [relocation_info]: Code relocation information
4997 // the kind of the code object.
5007 // [next_code_link]: Link for lists of optimized or deoptimized code.
5031 // [flags]: Various code flags.
5035 // [flags]: Access to specific code flags.
5074 // [is_crankshafted]: For kind STUB or ICs, tells whether or not a code
5082 // code object was generated by the TurboFan optimizing compiler.
5113 // the code object was seen on the stack with no IC patching going on.
5122 // reserved in the code prologue.
5148 // the code is going to be deoptimized because of dead embedded maps.
5170 Code* FindFirstHandler();
5177 MaybeHandle<Code> FindHandlerForMap(Map* map);
5184 // function replaces the corresponding placeholder in the code with the
5186 // the same order as the placeholders in the code.
5189 // The entire code object including its header is copied verbatim to the
5221 // Convert a target address into a code object.
5222 static inline Code* GetCodeFromTargetAddress(Address address);
5239 // Code entry point.
5245 // Relocate the code by delta bytes. Called to signal that this code
5249 // Migrate code described by desc.
5258 // Calculate the size of the code object to report for log events. This takes
5259 // the layout of the code object into account.
5261 // Check that the assumptions about the layout of the code object holds.
5263 Code::kHeaderSize);
5264 return instruction_size() + Code::kHeaderSize;
5271 DECLARE_CAST(Code)
5280 DECLARE_PRINTER(Code)
5281 DECLARE_VERIFIER(Code)
5304 // Code aging. Indicates how many full GCs this code has survived without
5306 // relatively safe to flush this code object and replace it with the lazy
5314 // Gets the raw code age, including psuedo code-age values such as
5317 static inline Code* GetPreAgedCodeAgeStub(Isolate* isolate) {
5369 // the Code object header.
5454 // Code aging
5456 static void GetCodeAgeAndParity(Code* code, Age* age,
5460 static Code* GetCodeAgeStub(Isolate* isolate, Age age, MarkingParity parity);
5462 // Code aging -- platform-specific
5467 DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
5483 // in the corresponding group. The subsequent elements contain grouped code
5486 // code objects within a group is not preserved.
5488 // All code indexes used in the class are counted starting from the first
5489 // code object of the first group. In other words, code index 0 corresponds
5500 // Group of code that weakly embed this map and depend on being
5503 // Group of code that embed a transition to this map, and depend on being
5506 // Group of code that omit run-time prototype checks for prototypes
5509 // possibly invalidating the assumptions embedded in the code.
5511 // Group of code that depends on elements not being added to objects with
5514 // Group of code that depends on global property values in property cells
5517 // Group of code that omit run-time type checks for the field(s) introduced
5520 // Group of code that omit run-time type checks for initial maps of
5523 // Group of code that depends on tenuring information in AllocationSites
5526 // Group of code that depends on element transition information in
5533 // Array for holding the index of the first code object of each group.
5534 // The last element stores the total number of code objects.
5545 bool Contains(DependencyGroup group, Code* code);
5551 Code* code);
5560 void AddToDependentICList(Handle<Code> stub);
5567 inline Code* code_at(int i);
5580 static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
5584 // code objects of the subsequent groups.
5646 // Keep this bit field at the very end for better code in
5859 // Returns true if map has a non-empty stub code cache.
5875 // [dependent code]: list of optimized codes that weakly embed this map.
6070 // Code cache operations.
6072 // Clears the code cache.
6075 // Update code cache.
6078 Handle<Code> code);
6087 // Returns the found code or undefined if absent.
6088 Object* FindInCodeCache(Name* name, Code::Flags flags);
6090 // Returns the non-negative index of the code object if it is in the
6092 Code* code);
6094 // Removes a code object from the code cache at the given index.
6095 void RemoveFromCodeCache(Name* name, Code* code, int index);
6148 Handle<Code> code);
6150 Handle<Code> stub);
6201 // Layout of pointer fields. Heap iteration code relies on them
6444 // [eval_from_instructions_offset]: the instruction offset in the code for the
6479 // Convert code position into column number.
6482 // Convert code position into (zero-based) line number.
6489 // Init line_ends array with code positions of line ends inside script source.
6530 // List of builtin functions we want to identify to improve code
6582 // [code]: Function code.
6583 DECL_ACCESSORS(code, Code)
6584 inline void ReplaceCode(Code* code);
6586 // [optimized_code_map]: Map from native context to optimized code
6591 // At position i - 1 is the context, position i the code, and i + 1 the
6595 // Installs optimized code from the code map on the given closure. The
6599 Code* GetCodeFromOptimizedCodeMap(int index);
6601 // Clear optimized code map.
6604 // Removed a specific optimized code object from the optimized code map.
6605 void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);
6609 // Trims the optimized code map after entries have been removed.
6612 // Add a new entry to the optimized code map.
6615 Handle<Code> code,
6619 // Layout description of the optimized code map.
6632 // [construct stub]: Code stub for constructing instances of this function.
6633 DECL_ACCESSORS(construct_stub, Code)
6635 // Returns if this function has been compiled to native code yet.
6647 // Set the formal parameter count so the function code will be
6656 // (increasingly) from crankshafted code where sufficient feedback isn't
6683 // [start_position_and_type]: Field used to store both the source code
6687 // expression and the rest contains the source code position.
6696 // profiling of JavaScript code written in OO style, where almost
6716 // Is this function a function expression in the source code.
6739 // This is used to determine if we can safely flush code from a function
6788 // Is this a function or top-level/eval code.
6791 // Indicates that code for this function cannot be cached.
6794 // Indicates that code for this function cannot be flushed.
6812 // Indicates whether or not the code in the shared function support
6816 // Enable deoptimization support through recompiled code.
6817 void EnableDeoptimizationSupport(Code* recompiled);
6826 // code, returns whether it asserted (i.e., always true if assertions are
6830 // [source code]: Source code for the function.
6983 // The source code start position is in the 30 most significant bits of
7090 // [continuation]: Offset into code of continuation.
7188 // [code]: The generated code object for this function. Executed
7192 inline Code* code();
7193 inline void set_code(Code* code);
7194 inline void set_code_no_write_barrier(Code* code);
7195 inline void ReplaceCode(Code* code);
7340 // Returns if this function has been compiled to native code yet.
7354 // Iterates the objects, including code objects indirectly referenced
7355 // through pointers to the first instruction in the code object.
7412 // [hash]: The hash code property (undefined if not initialized yet).
7497 // Accessors for code of the runtime routines written in JavaScript.
7498 inline Code* javascript_builtin_code(Builtins::JavaScript id);
7499 inline void set_javascript_builtin_code(Builtins::JavaScript id, Code* value);
7509 // (function and code object).
7648 // prevent leaking information to user code called during error
7703 // - a reference to code for Latin1 inputs (bytecode or compiled), or a smi
7704 // used for tracking the last usage (used for code flushing).
7705 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
7706 // used for tracking the last usage (used for code flushing)..
7715 // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
7783 // Irregexp compiled code or bytecode for Latin1. If compilation
7787 // Irregexp compiled code or bytecode for UC16. If compilation
7792 // Saved instance of Irregexp compiled code or bytecode for Latin1 that
7795 // Saved instance of Irregexp compiled code or bytecode for UC16 that is
7825 // The uninitialized value for a regexp code object.
7828 // The compilation error value for the regexp code object. The real error
7829 // object is in the saved code field.
7832 // When we store the sweep generation at which we moved the code from the
7833 // code index to the saved code index we mask it of to be in the [0:255]
7894 // Add the code object to the cache.
7896 Handle<CodeCache> cache, Handle<Name> name, Handle<Code> code);
7898 // Lookup code object in the cache. Returns code object if found and undefined
7900 Object* Lookup(Name* name, Code::Flags flags);
7902 // Get the internal index of a code object in the cache. Returns -1 if the
7903 // code object is not in that cache. This index can be used to later call
7906 int GetIndex(Object* name, Code* code);
7909 void RemoveByIndex(Object* name, Code* code, int index);
7924 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7926 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code);
7927 Object* LookupDefaultCache(Name* name, Code::Flags flags);
7928 Object* LookupNormalTypeCache(Name* name, Code::Flags flags);
7930 // Code cache layout of the default cache. Elements are alternating name and
7931 // code objects for non normal load/store/call IC's.
7965 Object* Lookup(Name* name, Code::Flags flags);
7969 Handle<Code> code);
7971 int GetIndex(Name* name, Code::Flags flags);
7990 Code::Flags flags,
7991 Handle<Code> code);
7995 Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
8022 Handle<Code> code);
8262 // During mark compact we need to take special care for the dependent code
8416 // concrete performance benefit at that particular point in the code.
8463 // Tells whether the hash code has been computed.
8487 // Mask constant for checking if a name has a computed hash code
8489 // indicates whether a hash code has been computed. If the hash code has
8496 // Shift constant retrieving hash code from hash field.
8926 // Compute and set the hash code.
9002 // For regexp code.
9211 // For regexp code.
9462 // [dependent_code]: dependent code that depends on the type of the global
9468 // a change of the type of the cell's contents, code dependent on the cell
9515 // [hash]: The hash code property (undefined if not initialized yet).
10576 // Code object for the original code.
10577 DECL_ACCESSORS(original_code, Code)
10578 // Code object for the patched code. This code object is the code object
10580 DECL_ACCESSORS(code, Code)
10584 // Check if there is a break point at a code position.
10586 // Get the break point info object for a code position.
10596 // Get the break point objects for a code position.
10624 // Lookup the index in the break_points array for a code position.
10632 // function. The DebugInfo object holds a BreakPointInfo object for each code
10636 // The position in the code for the break point.
10655 // Get the number of break points for this code position.
10726 // Visit weak next_code_link in Code object.
10730 // a rich interface for iterating over Code objects..
10732 // Visits a code target in the instruction stream.
10735 // Visits a code entry in a JS function.
10754 // about the code's age.
10757 // Visit pointer embedded into a code object.
10760 // Visits an external reference embedded into a code object.
