Lines Matching refs:Code
6 // * Redistributions of source code must retain the above copyright
104 // - Code
427 // code for the class including allocation and garbage collection routines,
817 V(Code) \
953 // Returns the permanent hash code associated with this object depending on
1066 // RuntimeStubs assumes EXCEPTION = 1 in the compiler-generated code.
1217 // from code that allocates and thus invalidates the returned write
1448 // Retrieves a permanent object identity hash code. The undefined value might
1490 // be quickly accessed. This fact is used in the generated code. The
1977 Handle<Code> code);
1979 MUST_USE_RESULT MaybeObject* UpdateMapCodeCache(String* name, Code* code);
2212 // common accessors and some code paths.
2281 // Code Generation support.
2364 // Code Generation support.
2830 // To scale a computed hash code to fit within the hash table, we
3351 // Return the number of stack slots for code. This number consists of two
3357 // Return the number of context slots for code if a context is allocated. This
3545 // that is attached to code objects.
3949 // data for code generated by the Hydrogen/Lithium compiler. It also
4032 // data for code generated by the full compiler.
4065 // cache cells and AST ids for code generated by the full compiler.
4104 // Code describes objects with on-the-fly generated machine code.
4105 class Code: public HeapObject {
4107 // Opaque data type for encapsulating code flags like kind, inline
4164 // [relocation_info]: Code relocation information
4194 // [flags]: Various code flags.
4198 // [flags]: Access to specific code flags.
4259 // the code object was seen on the stack with no IC patching going on.
4264 // reserved in the code prologue.
4309 // Mark this code object as not having a stack check table. Assumes kind
4363 // Convert a target address into a code object.
4364 static inline Code* GetCodeFromTargetAddress(Address address);
4381 // Code entry point.
4387 // Relocate the code by delta bytes. Called to signal that this code
4391 // Migrate code described by desc.
4400 // Calculate the size of the code object to report for log events. This takes
4401 // the layout of the code object into account.
4403 // Check that the assumptions about the layout of the code object holds.
4405 Code::kHeaderSize);
4406 return instruction_size() + Code::kHeaderSize;
4414 static inline Code* cast(Object* obj);
4456 // the Code object header.
4504 DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
4695 // Should only be called by the code that initializes map to set initial valid
4772 // Code cache operations.
4774 // Clears the code cache.
4777 // Update code cache.
4780 Handle<Code> code);
4781 MUST_USE_RESULT MaybeObject* UpdateCodeCache(String* name, Code* code);
4783 // Returns the found code or undefined if absent.
4784 Object* FindInCodeCache(String* name, Code::Flags flags);
4786 // Returns the non-negative index of the code object if it is in the
4788 int IndexInCodeCache(Object* name, Code* code);
4790 // Removes a code object from the code cache at the given index.
4791 void RemoveFromCodeCache(String* name, Code* code, int index);
4898 // Layout of pointer fields. Heap iteration code relies on them
4955 // Layout of the default cache. It holds alternating name and code objects.
5043 // [eval_from_instructions_offset]: the instruction offset in the code for the
5086 // List of builtin functions we want to identify to improve code
5143 // [code]: Function code.
5144 DECL_ACCESSORS(code, Code)
5149 // [construct stub]: Code stub for constructing instances of this function.
5150 DECL_ACCESSORS(construct_stub, Code)
5152 inline Code* unchecked_code();
5154 // Returns if this function has been compiled to native code yet.
5166 // Set the formal parameter count so the function code will be
5289 // [start_position_and_type]: Field used to store both the source code
5293 // expression and the rest contains the source code position.
5302 // profiling of JavaScript code written in OO style, where almost
5322 // Is this function a function expression in the source code.
5359 // This is used to determine if we can safely flush code from a function
5364 // code object. Used to determine when it is relatively safe to flush
5365 // this code object and replace it with lazy compilation stub.
5366 // Age is reset when GC notices that the code object is referenced
5377 // Indicates the language mode of the function's code as defined by the
5418 // Is this a function or top-level/eval code.
5427 // Indicates whether or not the code in the shared function support
5431 // Enable deoptimization support through recompiled code.
5432 void EnableDeoptimizationSupport(Code* recompiled);
5439 // code, returns whether it asserted (i.e., always true if assertions are
5461 // [source code]: Source code for the function.
5492 // Helpers to compile the shared code. Returns true on success, false on
5615 // The source code start position is in the 30 most significant bits of
5716 // [code]: The generated code object for this function. Executed
5720 inline Code* code();
5721 inline void set_code(Code* code);
5722 inline void ReplaceCode(Code* code);
5724 inline Code* unchecked_code();
5813 // Returns if this function has been compiled to native code yet.
5829 // Iterates the objects, including code objects indirectly referenced
5830 // through pointers to the first instruction in the code object.
5997 // Accessors for code of the runtime routines written in JavaScript.
5998 inline Code* javascript_builtin_code(Builtins::JavaScript id);
5999 inline void set_javascript_builtin_code(Builtins::JavaScript id, Code* value);
6017 // (function and code object).
6171 // prevent leaking information to user code called during error
6238 // - a reference to code for ASCII inputs (bytecode or compiled), or a smi
6239 // used for tracking the last usage (used for code flushing).
6240 // - a reference to code for UC16 inputs (bytecode or compiled), or a smi
6241 // used for tracking the last usage (used for code flushing)..
6250 // IRREGEXP_NATIVE: Compiled to native code with Irregexp.
6275 // Used during GC when flushing code or setting age.
6318 // Irregexp compiled code or bytecode for ASCII. If compilation
6322 // Irregexp compiled code or bytecode for UC16. If compilation
6327 // Saved instance of Irregexp compiled code or bytecode for ASCII that
6330 // Saved instance of Irregexp compiled code or bytecode for UC16 that is
6360 // The uninitialized value for a regexp code object.
6363 // The compilation error value for the regexp code object. The real error
6364 // object is in the saved code field.
6367 // When we store the sweep generation at which we moved the code from the
6368 // code index to the saved code index we mask it of to be in the [0:255]
6431 // Add the code object to the cache.
6432 MUST_USE_RESULT MaybeObject* Update(String* name, Code* code);
6434 // Lookup code object in the cache. Returns code object if found and undefined
6436 Object* Lookup(String* name, Code::Flags flags);
6438 // Get the internal index of a code object in the cache. Returns -1 if the
6439 // code object is not in that cache. This index can be used to later call
6442 int GetIndex(Object* name, Code* code);
6445 void RemoveByIndex(Object* name, Code* code, int index);
6465 MUST_USE_RESULT MaybeObject* UpdateDefaultCache(String* name, Code* code);
6466 MUST_USE_RESULT MaybeObject* UpdateNormalTypeCache(String* name, Code* code);
6467 Object* LookupDefaultCache(String* name, Code::Flags flags);
6468 Object* LookupNormalTypeCache(String* name, Code::Flags flags);
6470 // Code cache layout of the default cache. Elements are alternating name and
6471 // code objects for non normal load/store/call IC's.
6506 Object* Lookup(String* name, Code::Flags flags);
6507 MUST_USE_RESULT MaybeObject* Put(String* name, Code* code);
6509 int GetIndex(String* name, Code::Flags flags);
6528 Code::Flags flags,
6529 Handle<Code> code);
6532 Code::Flags flags,
6533 Code* code);
6536 Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags);
6565 Code* code);
6724 // concrete performance benefit at that particular point in the code.
6924 // Tells whether the hash code has been computed.
6977 // Max ASCII char code.
6982 // Mask constant for checking if a string has a computed hash code
6984 // whether a hash code has been computed. If the hash code has been
6991 // Shift constant retrieving hash code from hash field.
7139 // Compute and set the hash code.
7222 // For regexp code.
7465 // For regexp code.
7657 // [hash]: The hash code property (undefined if not initialized yet).
8365 // Code object for the original code.
8366 DECL_ACCESSORS(original_code, Code)
8367 // Code object for the patched code. This code object is the code object
8369 DECL_ACCESSORS(code, Code)
8373 // Check if there is a break point at a code position.
8375 // Get the break point info object for a code position.
8385 // Get the break point objects for a code position.
8417 // Lookup the index in the break_points array for a code position.
8425 // function. The DebugInfo object holds a BreakPointInfo object for each code
8429 // The position in the code for the break point.
8448 // Get the number of break points for this code position.
8520 // a rich interface for iterating over Code objects..
8522 // Visits a code target in the instruction stream.
8525 // Visits a code entry in a JS function.
8546 // Visit pointer embedded into a code object.
