// Copyright 2017 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef V8_OBJECTS_CODE_H_ #define V8_OBJECTS_CODE_H_ #include "src/codegen/maglev-safepoint-table.h" #include "src/objects/code-kind.h" #include "src/objects/struct.h" #include "src/objects/trusted-object.h" // Has to be the last include (doesn't have include guards): #include "src/objects/object-macros.h" namespace v8 { namespace internal { class BytecodeArray; class CodeDesc; class CodeWrapper; class Factory; template <typename Impl> class FactoryBase; class LocalFactory; class SafepointEntry; class RootVisitor; enum class Builtin; // Code is a container for data fields related to its associated // {InstructionStream} object. Since {InstructionStream} objects reside on // write-protected pages within the heap, its header fields need to be // immutable. Every InstructionStream object has an associated Code object, // but not every Code object has an InstructionStream (e.g. for builtins). // // Embedded builtins consist of on-heap Code objects, with an out-of-line body // section. Accessors (e.g. InstructionStart), redirect to the off-heap area. // Metadata table offsets remain relative to MetadataStart(), i.e. they point // into the off-heap metadata section. The off-heap layout is described in // detail in the EmbeddedData class, but at a high level one can assume a // dedicated, out-of-line, instruction and metadata section for each embedded // builtin: // // +--------------------------+ <-- InstructionStart() // | off-heap instructions | // | ... | // +--------------------------+ <-- InstructionEnd() // // +--------------------------+ <-- MetadataStart() (MS) // | off-heap metadata | // | ... | <-- MS + handler_table_offset() // | | <-- MS + constant_pool_offset() // | | <-- MS + code_comments_offset() // | | <-- MS + unwinding_info_offset() // +--------------------------+ <-- MetadataEnd() // // When the sandbox is enabled, Code objects are allocated outside the sandbox // and referenced through indirect pointers, so they need to inherit from // ExposedTrustedObject. class Code : public ExposedTrustedObject { … }; // A Code object when used in situations where gc might be in progress. The // underlying pointer is guaranteed to be a Code object. // // Semantics around Code and InstructionStream objects are quite delicate when // GC is in progress and objects are currently being moved, because the // tightly-coupled object pair {Code,InstructionStream} are conceptually // treated as a single object in our codebase, and we frequently convert // between the two. However, during GC, extra care must be taken when accessing // the `Code::instruction_stream` and `InstructionStream::code` slots because // they may contain forwarding pointers. // // This class a) clarifies at use sites that we're dealing with a Code object // in a situation that requires special semantics, and b) safely implements // related functions. // // Note that both the underlying Code object and the associated // InstructionStream may be forwarding pointers, thus type checks and normal // (checked) casts do not work on GcSafeCode. class GcSafeCode : public HeapObject { … }; // A CodeWrapper wraps a Code but lives inside the sandbox. This can be useful // for example when a reference to a Code needs to be stored along other tagged // pointers inside an array or similar container datastructure. class CodeWrapper : public Struct { … }; } // namespace internal } // namespace v8 #include "src/objects/object-macros-undef.h" #endif // V8_OBJECTS_CODE_H_