[x64] Improve key value sign-extension of dehoisted LoadKeyed/StoreKeyed

src/x64/lithium-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 157 matching lines @@
       return NULL;
   }
 }
 
 
 bool LGoto::HasInterestingComment(LCodeGen* gen) const {
   return !gen->IsNextEmittedBlock(block_id());
 }
 
 
+template<int R>
+bool LTemplateResultInstruction<R>::MustSignExtendResult(
+    LPlatformChunk* chunk) const {
+  HValue* hvalue = this->hydrogen_value();
+
+  if (hvalue == NULL) return false;
+  if (hvalue->HasRange() && !hvalue->range()->CanBeNegative()) return false;
+
+  return chunk->GetKeyValues()->Contains(hvalue->id());
+}
+
+
 void LGoto::PrintDataTo(StringStream* stream) {
   stream->Add("B%d", block_id());
 }
 
 
 void LBranch::PrintDataTo(StringStream* stream) {
   stream->Add("B%d | B%d on ", true_block_id(), false_block_id());
   value()->PrintTo(stream);
 }
 
@@ skipping 1769 matching lines @@
   return AssignEnvironment(DefineAsRegister(
       new(zone()) LLoadFunctionPrototype(UseRegister(instr->function()))));
 }
 
 
 LInstruction* LChunkBuilder::DoLoadRoot(HLoadRoot* instr) {
   return DefineAsRegister(new(zone()) LLoadRoot);
 }
 
 
+void RecordKeyValueThroughPhi(HValue* phi, BitVector* key_values) {

[danno, 2014/03/18 08:20:20]

This should be called FindDehoistedKeyDefinitions, make it a private member of
the ChunkBuilder so that you don't have to pass in the BitVector.

void LChunkBuilder::FindDehoistedKeyDefinitions(HValue* camdidate) {
  if (dehoisted_key_ids_->Contains(camdidate->id())) return;
  dehoisted_key_ids_->Add(value->id());
  if (!candidate->IsPhi()) return;
  for (int i = 0; i < candidate->OperandCount(); ++i) {
    FindDehoistedKeyDefinitions(candidate->OperandAt(i));
  }
}

[Weiliang, 2014/03/19 08:55:31]

The BitVector belongs to LChunk instead of LChunkBuilder. After making this
function private, BitVector is accessed through chunk_->GetDehoistedKeyIds()
Done.

+  ASSERT(phi->IsPhi());
+  for (int i = 0; i < phi->OperandCount(); ++i) {
+    HValue* value = phi->OperandAt(i);
+    if (key_values->Contains(value->id())) continue;
+    key_values->Add(value->id());
+    if (value->IsPhi()) {
+      RecordKeyValueThroughPhi(value, key_values);
+    }
+  }
+}
+
+
 LInstruction* LChunkBuilder::DoLoadKeyed(HLoadKeyed* instr) {
   ASSERT(instr->key()->representation().IsInteger32());
   ElementsKind elements_kind = instr->elements_kind();
   LOperand* key = UseRegisterOrConstantAtStart(instr->key());
   LLoadKeyed* result = NULL;
 
+  if (instr->IsDehoisted()) {
+    BitVector* key_values = chunk()->GetKeyValues();
+    if (!key_values->Contains(instr->key()->id())) {

[danno, 2014/03/18 08:20:20]

Move most of the logic here into RecordKeyValueThroughPhi. The code here should
be very simple:

if (instr->IsDehoisted()) {
  FindDehoistedKeyDefinitions(instr->key());
}

[Weiliang, 2014/03/19 08:55:31]

Done.

+      key_values->Add(instr->key()->id());
+      if (instr->key()->IsPhi()) {
+        RecordKeyValueThroughPhi(instr->key(), key_values);
+      }
+    }
+  }
+
   if (!instr->is_typed_elements()) {
     LOperand* obj = UseRegisterAtStart(instr->elements());
     result = new(zone()) LLoadKeyed(obj, key);
   } else {
     ASSERT(
         (instr->representation().IsInteger32() &&
          !(IsDoubleOrFloatElementsKind(instr->elements_kind()))) ||
         (instr->representation().IsDouble() &&
          (IsDoubleOrFloatElementsKind(instr->elements_kind()))));
     LOperand* backing_store = UseRegister(instr->elements());
@@ skipping 17 matching lines @@
 
   LLoadKeyedGeneric* result =
       new(zone()) LLoadKeyedGeneric(context, object, key);
   return MarkAsCall(DefineFixed(result, rax), instr);
 }
 
 
 LInstruction* LChunkBuilder::DoStoreKeyed(HStoreKeyed* instr) {
   ElementsKind elements_kind = instr->elements_kind();
 
+  if (instr->IsDehoisted()) {
+    BitVector* key_values = chunk()->GetKeyValues();

[danno, 2014/03/18 08:20:20]

See comment above.

[Weiliang, 2014/03/19 08:55:31]

Done.

+    if (!key_values->Contains(instr->key()->id())) {
+      key_values->Add(instr->key()->id());
+      if (instr->key()->IsPhi()) {
+        RecordKeyValueThroughPhi(instr->key(), key_values);
+      }
+    }
+  }
+
   if (!instr->is_typed_elements()) {
     ASSERT(instr->elements()->representation().IsTagged());
     bool needs_write_barrier = instr->NeedsWriteBarrier();
     LOperand* object = NULL;
     LOperand* key = NULL;
     LOperand* val = NULL;
 
     Representation value_representation = instr->value()->representation();
     if (value_representation.IsDouble()) {
       object = UseRegisterAtStart(instr->elements());
-      val = UseTempRegister(instr->value());
+      val = UseRegisterAtStart(instr->value());
       key = UseRegisterOrConstantAtStart(instr->key());
     } else {
       ASSERT(value_representation.IsSmiOrTagged() ||
              value_representation.IsInteger32());
       if (needs_write_barrier) {
         object = UseTempRegister(instr->elements());
         val = UseTempRegister(instr->value());
         key = UseTempRegister(instr->key());
       } else {
         object = UseRegisterAtStart(instr->elements());
@@ skipping 405 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   return DefineSameAsFirst(new(zone()) LLoadFieldByIndex(object, index));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64