Reland r20974: Unify and simplify the FastCloneShallowArrayStub

src/hydrogen-instructions.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include "v8.h"
 
 #include "allocation.h"
@@ skipping 600 matching lines @@
     // Set after an instruction is killed.
     kIsDead,
     // Instructions that are allowed to produce full range unsigned integer
     // values are marked with kUint32 flag. If arithmetic shift or a load from
     // EXTERNAL_UINT32_ELEMENTS array is not marked with this flag
     // it will deoptimize if result does not fit into signed integer range.
     // HGraph::ComputeSafeUint32Operations is responsible for setting this
     // flag.
     kUint32,
     kHasNoObservableSideEffects,
+    // Indicates an instruction shouldn't be replaced by optimization.

[mvstanton, 2014/05/09 13:16:49]

Or alternatively, instead of commenting the usage of kCantBeReplaced in
hydrogen.cc, expand on this comment a bit to indicate why you might want to use
this (reload is cheaper than spilling, say).

[danno, 2014/05/09 15:51:25]

Done.

+    kCantBeReplaced,
     // Indicates the instruction is live during dead code elimination.
     kIsLive,
 
     // HEnvironmentMarkers are deleted before dead code
     // elimination takes place, so they can repurpose the kIsLive flag:
     kEndsLiveRange = kIsLive,
 
     // TODO(everyone): Don't forget to update this!
     kLastFlag = kIsLive
   };
@@ skipping 5607 matching lines @@
     if (index == 0 && access().IsExternalMemory()) {
       // object must be external in case of external memory access
       return Representation::External();
     }
     return Representation::Tagged();
   }
   virtual Range* InferRange(Zone* zone) V8_OVERRIDE;
   virtual void PrintDataTo(StringStream* stream) V8_OVERRIDE;
 
   bool CanBeReplacedWith(HValue* other) const {
+    if (!CheckFlag(HValue::kCantBeReplaced)) return false;
     if (!type().Equals(other->type())) return false;
     if (!representation().Equals(other->representation())) return false;
     if (!other->IsLoadNamedField()) return true;
     HLoadNamedField* that = HLoadNamedField::cast(other);
     if (this->maps_ == that->maps_) return true;
     if (this->maps_ == NULL || that->maps_ == NULL) return false;
     return this->maps_->IsSubset(that->maps_);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
@@ skipping 43 matching lines @@
       set_representation(Representation::Tagged());
     }
     access.SetGVNFlags(this, LOAD);
   }
 
   HLoadNamedField(HValue* object,
                   HValue* dependency,
                   HObjectAccess access,
                   const UniqueSet<Map>* maps,
                   HType type)
-      : HTemplateInstruction<2>(type), access_(access), maps_(maps) {
+        : HTemplateInstruction<2>(type),
+          access_(access),
+          maps_(maps) {
     ASSERT_NOT_NULL(maps);
     ASSERT_NE(0, maps->size());
 
     ASSERT_NOT_NULL(object);
     SetOperandAt(0, object);
     SetOperandAt(1, dependency ? dependency : object);
 
     ASSERT(access.representation().IsHeapObject());
     // TODO(bmeurer): This is probably broken. What we actually want to to
     // instead is set_representation(Representation::HeapObject()).
@@ skipping 1329 matching lines @@
   virtual bool IsDeletable() const V8_OVERRIDE { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_