[ext-code-space] Add more accessors to CodeDataContainer

... in particular:
 * safepoint table accessors,
 * constant pool accessors,
 * handler table accessors.

This is a step towards Code-less embedded builtins.

Bug: v8:11880
Change-Id: I50c21000a821d0895295e4003ab321ddd8856546
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3764349Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Auto-Submit: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81779}

src/codegen/handler-table.cc

@@ -23,6 +23,12 @@ HandlerTable::HandlerTable(Code code)
     : HandlerTable(code.HandlerTableAddress(), code.handler_table_size(),
                    kReturnAddressBasedEncoding) {}
 
+#ifdef V8_EXTERNAL_CODE_SPACE
+HandlerTable::HandlerTable(CodeDataContainer code)
+    : HandlerTable(code.HandlerTableAddress(), code.handler_table_size(),
+                   kReturnAddressBasedEncoding) {}
+#endif  // V8_EXTERNAL_CODE_SPACE
+
 #if V8_ENABLE_WEBASSEMBLY
 HandlerTable::HandlerTable(const wasm::WasmCode* code)
     : HandlerTable(code->handler_table(), code->handler_table_size(),

src/codegen/handler-table.h

@@ -15,6 +15,8 @@ namespace internal {
 class Assembler;
 class ByteArray;
 class BytecodeArray;
+class Code;
+class CodeDataContainer;
 
 namespace wasm {
 class WasmCode;
@@ -53,6 +55,9 @@ class V8_EXPORT_PRIVATE HandlerTable {
 
   // Constructors for the various encodings.
   explicit HandlerTable(Code code);
+#ifdef V8_EXTERNAL_CODE_SPACE
+  explicit HandlerTable(CodeDataContainer code);
+#endif
   explicit HandlerTable(ByteArray byte_array);
 #if V8_ENABLE_WEBASSEMBLY
   explicit HandlerTable(const wasm::WasmCode* code);

src/codegen/safepoint-table.cc

@@ -24,6 +24,13 @@ SafepointTable::SafepointTable(Isolate* isolate, Address pc, Code code)
     : SafepointTable(code.InstructionStart(isolate, pc),
                      code.SafepointTableAddress()) {}
 
+#ifdef V8_EXTERNAL_CODE_SPACE
+SafepointTable::SafepointTable(Isolate* isolate, Address pc,
+                               CodeDataContainer code)
+    : SafepointTable(code.InstructionStart(isolate, pc),
+                     code.SafepointTableAddress()) {}
+#endif  // V8_EXTERNAL_CODE_SPACE
+
 #if V8_ENABLE_WEBASSEMBLY
 SafepointTable::SafepointTable(const wasm::WasmCode* code)
     : SafepointTable(

src/codegen/safepoint-table.h

@@ -61,6 +61,9 @@ class SafepointTable {
   // The isolate and pc arguments are used for figuring out whether pc
   // belongs to the embedded or un-embedded code blob.
   explicit SafepointTable(Isolate* isolate, Address pc, Code code);
+#ifdef V8_EXTERNAL_CODE_SPACE
+  explicit SafepointTable(Isolate* isolate, Address pc, CodeDataContainer code);
+#endif
 #if V8_ENABLE_WEBASSEMBLY
   explicit SafepointTable(const wasm::WasmCode* code);
 #endif  // V8_ENABLE_WEBASSEMBLY

src/objects/code-inl.h

@@ -503,10 +503,14 @@ int Code::SizeIncludingMetadata() const {
   return size;
 }
 
+Address Code::raw_safepoint_table_address() const {
+  return raw_metadata_start() + safepoint_table_offset();
+}
+
 Address Code::SafepointTableAddress() const {
   return V8_UNLIKELY(is_off_heap_trampoline())
              ? OffHeapSafepointTableAddress(*this, builtin_id())
-             : raw_metadata_start() + safepoint_table_offset();
+             : raw_safepoint_table_address();
 }
 
 int Code::safepoint_table_size() const {
@@ -516,10 +520,32 @@ int Code::safepoint_table_size() const {
 
 bool Code::has_safepoint_table() const { return safepoint_table_size() > 0; }
 
+#ifdef V8_EXTERNAL_CODE_SPACE
+Address CodeDataContainer::SafepointTableAddress() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapSafepointTableAddress(*this, builtin_id())
+             : code().raw_safepoint_table_address();
+}
+
+int CodeDataContainer::safepoint_table_size() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapSafepointTableSize(*this, builtin_id())
+             : code().safepoint_table_size();
+}
+
+bool CodeDataContainer::has_safepoint_table() const {
+  return safepoint_table_size() > 0;
+}
+#endif  // V8_EXTERNAL_CODE_SPACE
+
+Address Code::raw_handler_table_address() const {
+  return raw_metadata_start() + handler_table_offset();
+}
+
 Address Code::HandlerTableAddress() const {
   return V8_UNLIKELY(is_off_heap_trampoline())
              ? OffHeapHandlerTableAddress(*this, builtin_id())
-             : raw_metadata_start() + handler_table_offset();
+             : raw_handler_table_address();
 }
 
 int Code::handler_table_size() const {
@@ -529,6 +555,24 @@ int Code::handler_table_size() const {
 
 bool Code::has_handler_table() const { return handler_table_size() > 0; }
 
+#ifdef V8_EXTERNAL_CODE_SPACE
+Address CodeDataContainer::HandlerTableAddress() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapHandlerTableAddress(*this, builtin_id())
+             : code().raw_handler_table_address();
+}
+
+int CodeDataContainer::handler_table_size() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapHandlerTableSize(*this, builtin_id())
+             : code().handler_table_size();
+}
+
+bool CodeDataContainer::has_handler_table() const {
+  return handler_table_size() > 0;
+}
+#endif  // V8_EXTERNAL_CODE_SPACE
+
 int Code::constant_pool_size() const {
   const int size = code_comments_offset() - constant_pool_offset();
   DCHECK_IMPLIES(!FLAG_enable_embedded_constant_pool, size == 0);
@@ -538,6 +582,18 @@ int Code::constant_pool_size() const {
 
 bool Code::has_constant_pool() const { return constant_pool_size() > 0; }
 
+#ifdef V8_EXTERNAL_CODE_SPACE
+int CodeDataContainer::constant_pool_size() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapConstantPoolSize(*this, builtin_id())
+             : code().constant_pool_size();
+}
+
+bool CodeDataContainer::has_constant_pool() const {
+  return constant_pool_size() > 0;
+}
+#endif
+
 int Code::code_comments_size() const {
   DCHECK_GE(unwinding_info_offset() - code_comments_offset(), 0);
   return unwinding_info_offset() - code_comments_offset();
@@ -903,12 +959,24 @@ void Code::set_constant_pool_offset(int value) {
   WriteField<int>(kConstantPoolOffsetOffset, value);
 }
 
-Address Code::constant_pool() const {
+Address Code::raw_constant_pool() const {
   if (!has_constant_pool()) return kNullAddress;
+  return raw_metadata_start() + constant_pool_offset();
+}
+
+Address Code::constant_pool() const {
+  return V8_UNLIKELY(is_off_heap_trampoline())
+             ? OffHeapConstantPoolAddress(*this, builtin_id())
+             : raw_constant_pool();
+}
+
+#ifdef V8_EXTERNAL_CODE_SPACE
+Address CodeDataContainer::constant_pool() const {
   return V8_UNLIKELY(is_off_heap_trampoline())
              ? OffHeapConstantPoolAddress(*this, builtin_id())
-             : raw_metadata_start() + constant_pool_offset();
+             : code().raw_constant_pool();
 }
+#endif
 
 Address Code::code_comments() const {
   return V8_UNLIKELY(is_off_heap_trampoline())

src/objects/code.h

@@ -165,6 +165,18 @@ class CodeDataContainer : public HeapObject {
   DECL_GETTER(source_position_table, ByteArray)
   DECL_GETTER(bytecode_offset_table, ByteArray)
 
+  inline Address SafepointTableAddress() const;
+  inline int safepoint_table_size() const;
+  inline bool has_safepoint_table() const;
+
+  inline Address HandlerTableAddress() const;
+  inline int handler_table_size() const;
+  inline bool has_handler_table() const;
+
+  inline Address constant_pool() const;
+  inline int constant_pool_size() const;
+  inline bool has_constant_pool() const;
+
   // When builtins un-embedding is enabled for the Isolate
   // (see Isolate::is_short_builtin_calls_enabled()) then both embedded and
   // un-embedded builtins might be exeuted and thus two kinds of |pc|s might
@@ -360,6 +372,7 @@ class Code : public HeapObject {
 
   // [safepoint_table_offset]: The offset where the safepoint table starts.
   inline int safepoint_table_offset() const { return 0; }
+  inline Address raw_safepoint_table_address() const;
   inline Address SafepointTableAddress() const;
   inline int safepoint_table_size() const;
   inline bool has_safepoint_table() const;
@@ -368,6 +381,7 @@ class Code : public HeapObject {
   // starts.
   inline int handler_table_offset() const;
   inline void set_handler_table_offset(int offset);
+  inline Address raw_handler_table_address() const;
   inline Address HandlerTableAddress() const;
   inline int handler_table_size() const;
   inline bool has_handler_table() const;
@@ -375,6 +389,7 @@ class Code : public HeapObject {
   // [constant_pool offset]: Offset of the constant pool.
   inline int constant_pool_offset() const;
   inline void set_constant_pool_offset(int offset);
+  inline Address raw_constant_pool() const;
   inline Address constant_pool() const;
   inline int constant_pool_size() const;
   inline bool has_constant_pool() const;