1 files changed, 32 insertions, 39 deletions

diff --git a/deps/v8/src/turbo-assembler.cc b/deps/v8/src/turbo-assembler.cc
index 4bb09047bb..65e05aa45c 100644
--- a/deps/v8/src/turbo-assembler.cc
+++ b/deps/v8/src/turbo-assembler.cc
@@ -6,8 +6,8 @@
 
 #include "src/builtins/builtins.h"
 #include "src/builtins/constants-table-builder.h"
-#include "src/heap/heap-inl.h"
-#include "src/lsan.h"
+#include "src/isolate-data.h"
+#include "src/isolate-inl.h"
 #include "src/snapshot/serializer-common.h"
 
 namespace v8 {
@@ -15,9 +15,9 @@ namespace internal {
 
 TurboAssemblerBase::TurboAssemblerBase(Isolate* isolate,
                                        const AssemblerOptions& options,
-                                       void* buffer, int buffer_size,
-                                       CodeObjectRequired create_code_object)
-    : Assembler(options, buffer, buffer_size), isolate_(isolate) {
+                                       CodeObjectRequired create_code_object,
+                                       std::unique_ptr<AssemblerBuffer> buffer)
+    : Assembler(options, std::move(buffer)), isolate_(isolate) {
   if (create_code_object == CodeObjectRequired::kYes) {
     code_object_ = Handle<HeapObject>::New(
         ReadOnlyRoots(isolate).self_reference_marker(), isolate);
@@ -33,7 +33,7 @@ void TurboAssemblerBase::IndirectLoadConstant(Register destination,
 
   int builtin_index;
   RootIndex root_index;
-  if (isolate()->heap()->IsRootHandle(object, &root_index)) {
+  if (isolate()->roots_table().IsRootHandle(object, &root_index)) {
     // Roots are loaded relative to the root register.
     LoadRoot(destination, root_index);
   } else if (isolate()->builtins()->IsBuiltinHandle(object, &builtin_index)) {
@@ -71,62 +71,55 @@ void TurboAssemblerBase::IndirectLoadExternalReference(
     LoadRootRegisterOffset(destination, offset);
   } else {
     // Otherwise, do a memory load from the external reference table.
-
-    // Encode as an index into the external reference table stored on the
-    // isolate.
-    ExternalReferenceEncoder encoder(isolate());
-    ExternalReferenceEncoder::Value v = encoder.Encode(reference.address());
-    CHECK(!v.is_from_api());
-
-    LoadRootRelative(destination,
-                     RootRegisterOffsetForExternalReferenceIndex(v.index()));
+    LoadRootRelative(
+        destination,
+        RootRegisterOffsetForExternalReferenceTableEntry(isolate(), reference));
   }
 }
 
 // static
-int32_t TurboAssemblerBase::RootRegisterOffset(RootIndex root_index) {
-  return (static_cast<int32_t>(root_index) << kPointerSizeLog2) -
-         kRootRegisterBias;
+int32_t TurboAssemblerBase::RootRegisterOffsetForRootIndex(
+    RootIndex root_index) {
+  return IsolateData::root_slot_offset(root_index);
 }
 
 // static
-int32_t TurboAssemblerBase::RootRegisterOffsetForExternalReferenceIndex(
-    int reference_index) {
-  return Heap::roots_to_external_reference_table_offset() - kRootRegisterBias +
-         ExternalReferenceTable::OffsetOfEntry(reference_index);
+int32_t TurboAssemblerBase::RootRegisterOffsetForBuiltinIndex(
+    int builtin_index) {
+  return IsolateData::builtin_slot_offset(builtin_index);
 }
 
 // static
 intptr_t TurboAssemblerBase::RootRegisterOffsetForExternalReference(
     Isolate* isolate, const ExternalReference& reference) {
-  return static_cast<intptr_t>(reference.address()) - kRootRegisterBias -
-         reinterpret_cast<intptr_t>(isolate->heap()->roots_array_start());
+  return static_cast<intptr_t>(reference.address() - isolate->isolate_root());
 }
 
 // static
-bool TurboAssemblerBase::IsAddressableThroughRootRegister(
+int32_t TurboAssemblerBase::RootRegisterOffsetForExternalReferenceTableEntry(
     Isolate* isolate, const ExternalReference& reference) {
-  Address address = reference.address();
-  return isolate->root_register_addressable_region().contains(address);
+  // Encode as an index into the external reference table stored on the
+  // isolate.
+  ExternalReferenceEncoder encoder(isolate);
+  ExternalReferenceEncoder::Value v = encoder.Encode(reference.address());
+  CHECK(!v.is_from_api());
+
+  return IsolateData::external_reference_table_offset() +
+         ExternalReferenceTable::OffsetOfEntry(v.index());
 }
 
 // static
-int32_t TurboAssemblerBase::RootRegisterOffsetForBuiltinIndex(
-    int builtin_index) {
-  return Heap::roots_to_builtins_offset() - kRootRegisterBias +
-         builtin_index * kPointerSize;
+bool TurboAssemblerBase::IsAddressableThroughRootRegister(
+    Isolate* isolate, const ExternalReference& reference) {
+  Address address = reference.address();
+  return isolate->root_register_addressable_region().contains(address);
 }
 
 void TurboAssemblerBase::RecordCommentForOffHeapTrampoline(int builtin_index) {
   if (!FLAG_code_comments) return;
-  size_t len = strlen("-- Inlined Trampoline to  --") +
-               strlen(Builtins::name(builtin_index)) + 1;
-  Vector<char> buffer = Vector<char>::New(static_cast<int>(len));
-  char* buffer_start = buffer.start();
-  LSAN_IGNORE_OBJECT(buffer_start);
-  SNPrintF(buffer, "-- Inlined Trampoline to %s --",
-           Builtins::name(builtin_index));
-  RecordComment(buffer_start);
+  std::ostringstream str;
+  str << "-- Inlined Trampoline to " << Builtins::name(builtin_index) << " --";
+  RecordComment(str.str().c_str());
 }
 
 }  // namespace internal