Remove fixed contant pool entries by caching some global constants in Thread

runtime/vm/assembler_x64.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // NOLINT
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/heap.h"
@@ skipping 10 matching lines @@
 DECLARE_FLAG(bool, inline_alloc);
 
 
 Assembler::Assembler(bool use_far_branches)
     : buffer_(),
       prologue_offset_(-1),
       comments_(),
       allow_constant_pool_(true) {
   // Far branching mode is only needed and implemented for MIPS and ARM.
   ASSERT(!use_far_branches);
-  Isolate* isolate = Isolate::Current();
-  if (isolate != Dart::vm_isolate()) {
-    // These objects and labels need to be accessible through every pool-pointer
-    // at the same index.
-    intptr_t index = object_pool_wrapper_.AddObject(Object::null_object());
-    ASSERT(index == 0);
-
-    index = object_pool_wrapper_.AddObject(Bool::True());
-    ASSERT(index == 1);
-
-    index = object_pool_wrapper_.AddObject(Bool::False());
-    ASSERT(index == 2);
-
-    const Smi& vacant = Smi::Handle(Smi::New(0xfa >> kSmiTagShift));
-    StubCode* stub_code = isolate->stub_code();
-    if (stub_code->UpdateStoreBuffer_entry() != NULL) {
-      object_pool_wrapper_.AddExternalLabel(
-          &stub_code->UpdateStoreBufferLabel(), kNotPatchable);
-    } else {
-      object_pool_wrapper_.AddObject(vacant);
-    }
-  }
 }
 
 
 void Assembler::InitializeMemoryWithBreakpoints(uword data, intptr_t length) {
   memset(reinterpret_cast<void*>(data), Instr::kBreakPointInstruction, length);
 }
 
 
 void Assembler::call(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
@@ skipping 2724 matching lines @@
   if (stack_elements <= 4) {
     for (intptr_t i = 0; i < stack_elements; i++) {
       popq(tmp);
     }
     return;
   }
   addq(RSP, Immediate(stack_elements * kWordSize));
 }
 
 
-// A set of VM objects that are present in every constant pool.
-static bool IsAlwaysInConstantPool(const Object& object) {
-  // TODO(zra): Evaluate putting all VM heap objects into the pool.
-  return (object.raw() == Object::null())
-      || (object.raw() == Bool::True().raw())
-      || (object.raw() == Bool::False().raw());
-}
-
-
 bool Assembler::CanLoadFromObjectPool(const Object& object) {

[srdjan, 2015/07/07 16:58:27]

const

[Florian Schneider, 2015/07/08 09:28:09]

Done.

+  ASSERT(!Thread::CanLoadFromThread(object));
   if (!allow_constant_pool()) {
-    return IsAlwaysInConstantPool(object);
+    return false;
   }
 
   // TODO(zra, kmillikin): Also load other large immediates from the object
   // pool
   if (object.IsSmi()) {
     // If the raw smi does not fit into a 32-bit signed int, then we'll keep
     // the raw value in the object pool.
     return !Utils::IsInt(32, reinterpret_cast<int64_t>(object.raw()));
   }
   ASSERT(object.IsNotTemporaryScopedHandle());
   ASSERT(object.IsOld());
   return (Isolate::Current() != Dart::vm_isolate());
 }
 
 
 void Assembler::LoadWordFromPoolOffset(Register dst, Register pp,
                                        int32_t offset) {
   // This sequence must be of fixed size. AddressBaseImm32
   // forces the address operand to use a fixed-size imm32 encoding.
   movq(dst, Address::AddressBaseImm32(pp, offset));
 }
 
 
 void Assembler::LoadIsolate(Register dst) {
   movq(dst, Address(THR, Thread::isolate_offset()));
 }
 
 
 void Assembler::LoadObject(Register dst, const Object& object, Register pp) {
-  if (CanLoadFromObjectPool(object)) {
+  if (Thread::CanLoadFromThread(object)) {
+    movq(dst, Address(THR, Thread::OffsetFromThread(object)));
+  } else if (CanLoadFromObjectPool(object)) {
     const int32_t offset =
         ObjectPool::element_offset(object_pool_wrapper_.FindObject(object));
     LoadWordFromPoolOffset(dst, pp, offset - kHeapObjectTag);
   } else {
     ASSERT((Isolate::Current() == Dart::vm_isolate()) ||
            object.IsSmi() ||
            object.InVMHeap());
     LoadImmediate(dst, Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
   }
 }
 
 
 void Assembler::StoreObject(const Address& dst, const Object& object,
                             Register pp) {
-  if (CanLoadFromObjectPool(object)) {
+  if (Thread::CanLoadFromThread(object)) {
+    movq(TMP, Address(THR, Thread::OffsetFromThread(object)));
+    movq(dst, TMP);
+  } else if (CanLoadFromObjectPool(object)) {
     LoadObject(TMP, object, pp);
     movq(dst, TMP);
   } else {
     MoveImmediate(dst, Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
   }
 }
 
 
 void Assembler::PushObject(const Object& object, Register pp) {
-  if (CanLoadFromObjectPool(object)) {
+  if (Thread::CanLoadFromThread(object)) {
+    pushq(Address(THR, Thread::OffsetFromThread(object)));
+  } else if (CanLoadFromObjectPool(object)) {
     LoadObject(TMP, object, pp);
     pushq(TMP);
   } else {
     PushImmediate(Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
   }
 }
 
 
 void Assembler::CompareObject(Register reg, const Object& object, Register pp) {
-  if (CanLoadFromObjectPool(object)) {
+  if (Thread::CanLoadFromThread(object)) {
+    cmpq(reg, Address(THR, Thread::OffsetFromThread(object)));
+  } else if (CanLoadFromObjectPool(object)) {
     const int32_t offset =
         ObjectPool::element_offset(object_pool_wrapper_.FindObject(object));
     cmpq(reg, Address(pp, offset-kHeapObjectTag));
   } else {
     CompareImmediate(
         reg, Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
   }
 }
 
 
@@ skipping 183 matching lines @@
   if (can_value_be_smi) {
     StoreIntoObjectFilter(object, value, &done);
   } else {
     StoreIntoObjectFilterNoSmi(object, value, &done);
   }
   // A store buffer update is required.
   if (value != RDX) pushq(RDX);
   if (object != RDX) {
     movq(RDX, object);
   }
-  StubCode* stub_code = Isolate::Current()->stub_code();
-  Call(&stub_code->UpdateStoreBufferLabel(), PP);
+  movq(TMP, Address(THR, Thread::update_store_buffer_entry_point_offset()));
+  call(TMP);
   if (value != RDX) popq(RDX);
   Bind(&done);
 }
 
 
 void Assembler::StoreIntoObjectNoBarrier(Register object,
                                          const Address& dest,
                                          Register value,
                                          FieldContent old_content) {
   VerifiedWrite(dest, value, old_content);
@@ skipping 835 matching lines @@
 
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64