Version 2.14.0-181.0.dev

Merge commit '6c254fab89adbeebfb616cdec497260db4cb7cf7' into 'dev'

Author: Dart CI

runtime/lib/object.cc

@@ -52,19 +52,15 @@ DEFINE_NATIVE_ENTRY(Object_getHash, 0, 1) {
 
 DEFINE_NATIVE_ENTRY(Object_setHashIfNotSetYet, 0, 2) {
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, hash, arguments->NativeArgAt(1));
-  const intptr_t current_hash = GetHash(isolate, arguments->NativeArgAt(0));
-  if (current_hash != 0) {
-    return Smi::New(current_hash);
-  }
 #if defined(HASH_IN_OBJECT_HEADER)
-  Object::SetCachedHash(arguments->NativeArgAt(0), hash.Value());
+  return Smi::New(
+      Object::SetCachedHashIfNotSet(arguments->NativeArgAt(0), hash.Value()));
 #else
   const Instance& instance =
       Instance::CheckedHandle(zone, arguments->NativeArgAt(0));
-  Heap* heap = isolate->group()->heap();
-  heap->SetHash(instance.ptr(), hash.Value());
+  Heap* heap = thread->heap();
+  return Smi::New(heap->SetHashIfNotSet(instance.ptr(), hash.Value()));
 #endif
-  return hash.ptr();
 }
 
 DEFINE_NATIVE_ENTRY(Object_toString, 0, 1) {

runtime/vm/compiler/asm_intrinsifier_arm64.cc

@@ -1601,26 +1601,27 @@ void AsmIntrinsifier::Object_getHash(Assembler* assembler,
 
 void AsmIntrinsifier::Object_setHashIfNotSetYet(Assembler* assembler,
                                                 Label* normal_ir_body) {
-  Label already_set;
-  __ ldr(R0, Address(SP, 1 * target::kWordSize));  // Object.
-  __ ldr(R1, FieldAddress(R0, target::String::hash_offset(), kFourBytes),
-         kUnsignedFourBytes);
-  __ cbnz(&already_set, R1, kFourBytes);
-  __ ldr(R1, Address(SP, 0 * target::kWordSize));  // Value.
+  __ ldp(/*Value=*/R1, /*Object=*/R0, Address(SP, 0, Address::PairOffset));
   // R0: Untagged address of header word (ldxr/stxr do not support offsets).
   __ sub(R0, R0, Operand(kHeapObjectTag));
   __ SmiUntag(R1);
   __ LslImmediate(R3, R1, target::UntaggedObject::kHashTagPos);
-  Label retry;
+
+  Label retry, already_set_in_r4;
   __ Bind(&retry);
   __ ldxr(R2, R0, kEightBytes);
+  __ LsrImmediate(R4, R2, target::UntaggedObject::kHashTagPos);
+  __ cbnz(&already_set_in_r4, R4);
   __ orr(R2, R2, Operand(R3));
   __ stxr(R4, R2, R0, kEightBytes);
   __ cbnz(&retry, R4);
   // Fall-through with R1 containing new hash value (untagged).
-  __ Bind(&already_set);
   __ SmiTag(R0, R1);
   __ ret();
+  __ Bind(&already_set_in_r4);
+  __ clrex();
+  __ SmiTag(R0, R4);
+  __ ret();
 }
 
 void GenerateSubstringMatchesSpecialization(Assembler* assembler,

runtime/vm/compiler/asm_intrinsifier_test.cc

@@ -0,0 +1,81 @@
+// Copyright (c) 2021, 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 "platform/assert.h"
+
+#include "vm/globals.h"
+#include "vm/symbols.h"
+#include "vm/unit_test.h"
+
+namespace dart {
+
+static intptr_t GetHash(Isolate* isolate, const ObjectPtr obj) {
+#if defined(HASH_IN_OBJECT_HEADER)
+  return Object::GetCachedHash(obj);
+#else
+  Heap* heap = isolate->group()->heap();
+  ASSERT(obj->IsDartInstance());
+  return heap->GetHash(obj);
+#endif
+}
+
+ISOLATE_UNIT_TEST_CASE(AsmIntrinsifier_SetHashIfNotSetYet) {
+  auto I = Isolate::Current();
+  const auto& corelib = Library::Handle(Library::CoreLibrary());
+  const auto& name = String::Handle(String::New("_setHashIfNotSetYet"));
+  const auto& symbol = String::Handle(Symbols::New(thread, name));
+
+  const auto& function =
+      Function::Handle(corelib.LookupFunctionAllowPrivate(symbol));
+  const auto& object_class =
+      Class::Handle(corelib.LookupClass(Symbols::Object()));
+
+  auto& smi0 = Smi::Handle(Smi::New(0));
+  auto& smi21 = Smi::Handle(Smi::New(21));
+  auto& smi42 = Smi::Handle(Smi::New(42));
+  const auto& obj = Object::Handle(Instance::New(object_class));
+  const auto& args = Array::Handle(Array::New(2));
+
+  const auto& args_descriptor_array =
+      Array::Handle(ArgumentsDescriptor::NewBoxed(0, 2, Array::empty_array()));
+
+  // Initialized to 0
+  EXPECT_EQ(smi0.ptr(), Smi::New(GetHash(I, obj.ptr())));
+
+  // Lazily set to 42 on first call.
+  args.SetAt(0, obj);
+  args.SetAt(1, smi42);
+  EXPECT_EQ(smi42.ptr(),
+            DartEntry::InvokeFunction(function, args, args_descriptor_array));
+  EXPECT_EQ(smi42.ptr(), Smi::New(GetHash(I, obj.ptr())));
+
+  // Stays at 42 on subsequent calls.
+  args.SetAt(0, obj);
+  args.SetAt(1, smi21);
+  EXPECT_EQ(smi42.ptr(),
+            DartEntry::InvokeFunction(function, args, args_descriptor_array));
+  EXPECT_EQ(smi42.ptr(), Smi::New(GetHash(I, obj.ptr())));
+
+  const auto& obj2 = Object::Handle(Instance::New(object_class));
+  const auto& smiMax = Smi::Handle(Smi::New(0xffffffff));
+
+  // Initialized to 0
+  EXPECT_EQ(smi0.ptr(), Smi::New(GetHash(I, obj2.ptr())));
+
+  // Lazily set to smiMax first call.
+  args.SetAt(0, obj2);
+  args.SetAt(1, smiMax);
+  EXPECT_EQ(smiMax.ptr(),
+            DartEntry::InvokeFunction(function, args, args_descriptor_array));
+  EXPECT_EQ(smiMax.ptr(), Smi::New(GetHash(I, obj2.ptr())));
+
+  // Stays at smiMax on subsequent calls.
+  args.SetAt(0, obj2);
+  args.SetAt(1, smi21);
+  EXPECT_EQ(smiMax.ptr(),
+            DartEntry::InvokeFunction(function, args, args_descriptor_array));
+  EXPECT_EQ(smiMax.ptr(), Smi::New(GetHash(I, obj2.ptr())));
+}
+
+}  // namespace dart

runtime/vm/compiler/asm_intrinsifier_x64.cc

@@ -1455,23 +1455,35 @@ void AsmIntrinsifier::Object_getHash(Assembler* assembler,
 
 void AsmIntrinsifier::Object_setHashIfNotSetYet(Assembler* assembler,
                                                 Label* normal_ir_body) {
-  Label already_set;
-  __ movq(RAX, Address(RSP, +2 * target::kWordSize));  // Object.
-  __ movl(RDX, FieldAddress(RAX, target::String::hash_offset()));
-  __ testl(RDX, RDX);
-  __ j(NOT_ZERO, &already_set, AssemblerBase::kNearJump);
-  __ movq(RDX, Address(RSP, +1 * target::kWordSize));  // Value.
-  __ SmiUntag(RDX);
-  __ shlq(RDX, Immediate(target::UntaggedObject::kHashTagPos));
-  // lock+orq is an atomic read-modify-write.
-  __ lock();
-  __ orq(FieldAddress(RAX, target::Object::tags_offset()), RDX);
-  __ movq(RAX, Address(RSP, +1 * target::kWordSize));
-  __ ret();
-  __ Bind(&already_set);
-  __ movl(RAX, RDX);
+  ASSERT(target::String::hash_offset() == 4);
+
+  __ movq(RBX, Address(RSP, +2 * target::kWordSize));  // Object.
+  __ movq(RCX, Address(RSP, +1 * target::kWordSize));  // Value.
+  __ SmiUntag(RCX);
+  __ MoveRegister(RDX, RCX);
+  __ shlq(RDX, Immediate(32));
+
+  Label retry, success, already_in_rax;
+  __ Bind(&retry);
+  // RAX is used by "cmpxchgq" as comparison value (if comparison succeeds the
+  // store is performed).
+  __ movq(RAX, FieldAddress(RBX, 0));
+  __ TestImmediate(RAX, Immediate(0xffffffff00000000));
+  __ BranchIf(NOT_ZERO, &already_in_rax);
+  __ MoveRegister(RSI, RAX);
+  __ orq(RSI, RDX);
+  __ LockCmpxchgq(FieldAddress(RBX, 0), RSI);
+  __ BranchIf(NOT_ZERO, &retry);
+  // Fall-through with RCX containing new hash value (untagged)
+  __ Bind(&success);
+  __ SmiTag(RCX);
+  __ MoveRegister(RAX, RCX);
+  __ Ret();
+
+  __ Bind(&already_in_rax);
+  __ shrq(RAX, Immediate(32));
   __ SmiTag(RAX);
-  __ ret();
+  __ Ret();
 }
 
 void GenerateSubstringMatchesSpecialization(Assembler* assembler,

runtime/vm/compiler/backend/linearscan.cc

@@ -2239,17 +2239,29 @@ bool FlowGraphAllocator::AllocateFreeRegister(LiveRange* unallocated) {
     }
   }
 
-  TRACE_ALLOC(THR_Print("assigning free register "));
-  TRACE_ALLOC(MakeRegisterLocation(candidate).Print());
-  TRACE_ALLOC(THR_Print(" to v%" Pd "\n", unallocated->vreg()));
-
   if (free_until != kMaxPosition) {
     // There was an intersection. Split unallocated.
     TRACE_ALLOC(THR_Print("  splitting at %" Pd "\n", free_until));
     LiveRange* tail = unallocated->SplitAt(free_until);
     AddToUnallocated(tail);
+
+    // If unallocated represents a constant value and does not have
+    // any uses then avoid using a register for it.
+    if (unallocated->first_use() == NULL) {
+      if (unallocated->vreg() >= 0) {
+        LiveRange* parent = GetLiveRange(unallocated->vreg());
+        if (parent->spill_slot().IsConstant()) {
+          Spill(unallocated);
+          return true;
+        }
+      }
+    }
   }
 
+  TRACE_ALLOC(THR_Print("  assigning free register "));
+  TRACE_ALLOC(MakeRegisterLocation(candidate).Print());
+  TRACE_ALLOC(THR_Print(" to v%" Pd "\n", unallocated->vreg()));
+
   registers_[candidate]->Add(unallocated);
   unallocated->set_assigned_location(MakeRegisterLocation(candidate));
   return true;

runtime/vm/compiler/compiler_sources.gni

@@ -154,6 +154,7 @@ compiler_sources = [
 ]
 
 compiler_sources_tests = [
+  "asm_intrinsifier_test.cc",
   "assembler/assembler_arm64_test.cc",
   "assembler/assembler_arm_test.cc",
   "assembler/assembler_ia32_test.cc",

runtime/vm/heap/become.cc

@@ -297,7 +297,7 @@ void Become::ElementsForwardIdentity(const Array& before, const Array& after) {
     ForwardObjectTo(before_obj, after_obj);
     heap->ForwardWeakEntries(before_obj, after_obj);
 #if defined(HASH_IN_OBJECT_HEADER)
-    Object::SetCachedHash(after_obj, Object::GetCachedHash(before_obj));
+    Object::SetCachedHashIfNotSet(after_obj, Object::GetCachedHash(before_obj));
 #endif
   }
 

runtime/vm/heap/heap.cc

@@ -893,6 +893,17 @@ void Heap::SetWeakEntry(ObjectPtr raw_obj, WeakSelector sel, intptr_t val) {
   }
 }
 
+intptr_t Heap::SetWeakEntryIfNonExistent(ObjectPtr raw_obj,
+                                         WeakSelector sel,
+                                         intptr_t val) {
+  if (!raw_obj->IsSmiOrOldObject()) {
+    return new_weak_tables_[sel]->SetValueIfNonExistent(raw_obj, val);
+  } else {
+    ASSERT(raw_obj->IsSmiOrOldObject());
+    return old_weak_tables_[sel]->SetValueIfNonExistent(raw_obj, val);
+  }
+}
+
 void Heap::ForwardWeakEntries(ObjectPtr before_object, ObjectPtr after_object) {
   const auto before_space =
       !before_object->IsSmiOrOldObject() ? Heap::kNew : Heap::kOld;

runtime/vm/heap/heap.h

@@ -211,8 +211,8 @@ class Heap {
 #if !defined(HASH_IN_OBJECT_HEADER)
   // Associate an identity hashCode with an object. An non-existent hashCode
   // is equal to 0.
-  void SetHash(ObjectPtr raw_obj, intptr_t hash) {
-    SetWeakEntry(raw_obj, kIdentityHashes, hash);
+  intptr_t SetHashIfNotSet(ObjectPtr raw_obj, intptr_t hash) {
+    return SetWeakEntryIfNonExistent(raw_obj, kIdentityHashes, hash);
   }
   intptr_t GetHash(ObjectPtr raw_obj) const {
     return GetWeakEntry(raw_obj, kIdentityHashes);
@@ -251,6 +251,9 @@ class Heap {
   // Used by the GC algorithms to propagate weak entries.
   intptr_t GetWeakEntry(ObjectPtr raw_obj, WeakSelector sel) const;
   void SetWeakEntry(ObjectPtr raw_obj, WeakSelector sel, intptr_t val);
+  intptr_t SetWeakEntryIfNonExistent(ObjectPtr raw_obj,
+                                     WeakSelector sel,
+                                     intptr_t val);
 
   WeakTable* GetWeakTable(Space space, WeakSelector selector) const {
     if (space == kNew) {

runtime/vm/heap/weak_table.h

@@ -62,6 +62,16 @@ class WeakTable {
     return SetValueExclusive(key, val);
   }
 
+  intptr_t SetValueIfNonExistent(ObjectPtr key, intptr_t val) {
+    MutexLocker ml(&mutex_);
+    const auto old_value = GetValueExclusive(key);
+    if (old_value == kNoValue) {
+      SetValueExclusive(key, val);
+      return val;
+    }
+    return old_value;
+  }
+
   // The following "exclusive" methods must only be called from call sites
   // which are known to have exclusive access to the weak table.
   //