[turbofan] Make New*Elements operator naming consistent.

We no longer use the terminology "fast elements", so drop the "Fast"
from both NewFastSmiOrObjectElements and NewFastDoubleElements operator
names.

Bug: v8:6399, v8:6901
Tbr: jarin@chromium.org
Change-Id: Icc204623f2b459b0d0e172e26ddd73e29fe6c884
Reviewed-on: https://chromium-review.googlesource.com/707246Reviewed-by: Benedikt Meurer <bmeurer@chromium.org>
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48399}

src/compiler/effect-control-linearizer.cc

@@ -810,11 +810,11 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
     case IrOpcode::kArgumentsLength:
       result = LowerArgumentsLength(node);
       break;
-    case IrOpcode::kNewFastDoubleElements:
-      result = LowerNewFastDoubleElements(node);
+    case IrOpcode::kNewDoubleElements:
+      result = LowerNewDoubleElements(node);
       break;
-    case IrOpcode::kNewFastSmiOrObjectElements:
-      result = LowerNewFastSmiOrObjectElements(node);
+    case IrOpcode::kNewSmiOrObjectElements:
+      result = LowerNewSmiOrObjectElements(node);
       break;
     case IrOpcode::kNewArgumentsElements:
       result = LowerNewArgumentsElements(node);
@@ -2281,7 +2281,7 @@ Node* EffectControlLinearizer::LowerArgumentsFrame(Node* node) {
   return done.PhiAt(0);
 }
 
-Node* EffectControlLinearizer::LowerNewFastDoubleElements(Node* node) {
+Node* EffectControlLinearizer::LowerNewDoubleElements(Node* node) {
   PretenureFlag const pretenure = PretenureFlagOf(node->op());
   Node* length = node->InputAt(0);
 
@@ -2328,7 +2328,7 @@ Node* EffectControlLinearizer::LowerNewFastDoubleElements(Node* node) {
   return result;
 }
 
-Node* EffectControlLinearizer::LowerNewFastSmiOrObjectElements(Node* node) {
+Node* EffectControlLinearizer::LowerNewSmiOrObjectElements(Node* node) {
   PretenureFlag const pretenure = PretenureFlagOf(node->op());
   Node* length = node->InputAt(0);
 

src/compiler/effect-control-linearizer.h

@@ -98,8 +98,8 @@ class V8_EXPORT_PRIVATE EffectControlLinearizer {
   Node* LowerObjectIsUndetectable(Node* node);
   Node* LowerArgumentsFrame(Node* node);
   Node* LowerArgumentsLength(Node* node);
-  Node* LowerNewFastDoubleElements(Node* node);
-  Node* LowerNewFastSmiOrObjectElements(Node* node);
+  Node* LowerNewDoubleElements(Node* node);
+  Node* LowerNewSmiOrObjectElements(Node* node);
   Node* LowerNewArgumentsElements(Node* node);
   Node* LowerArrayBufferWasNeutered(Node* node);
   Node* LowerStringCharAt(Node* node);

src/compiler/js-create-lowering.cc

@@ -604,11 +604,11 @@ Reduction JSCreateLowering::ReduceNewArray(Node* node, Node* length,
       control);
 
   // Construct elements and properties for the resulting JSArray.
-  Node* elements = effect = graph()->NewNode(
-      IsDoubleElementsKind(initial_map->elements_kind())
-          ? simplified()->NewFastDoubleElements(pretenure)
-          : simplified()->NewFastSmiOrObjectElements(pretenure),
-      length, effect, control);
+  Node* elements = effect =
+      graph()->NewNode(IsDoubleElementsKind(initial_map->elements_kind())
+                           ? simplified()->NewDoubleElements(pretenure)
+                           : simplified()->NewSmiOrObjectElements(pretenure),
+                       length, effect, control);
   Node* properties = jsgraph()->EmptyFixedArrayConstant();
 
   // Perform the allocation of the actual JSArray object.

src/compiler/opcodes.h

@@ -369,8 +369,8 @@
   V(ObjectIsUndetectable)           \
   V(ArgumentsFrame)                 \
   V(ArgumentsLength)                \
-  V(NewFastDoubleElements)          \
-  V(NewFastSmiOrObjectElements)     \
+  V(NewDoubleElements)              \
+  V(NewSmiOrObjectElements)         \
   V(NewArgumentsElements)           \
   V(ArrayBufferWasNeutered)         \
   V(EnsureWritableFastElements)     \

src/compiler/simplified-lowering.cc

@@ -2787,8 +2787,8 @@ class RepresentationSelector {
                   MachineRepresentation::kTaggedSigned);
         return;
       }
-      case IrOpcode::kNewFastDoubleElements:
-      case IrOpcode::kNewFastSmiOrObjectElements: {
+      case IrOpcode::kNewDoubleElements:
+      case IrOpcode::kNewSmiOrObjectElements: {
         VisitUnop(node, UseInfo::TruncatingWord32(),
                   MachineRepresentation::kTaggedPointer);
         return;

src/compiler/simplified-operator.cc

@@ -397,8 +397,8 @@ bool operator!=(AllocateParameters const& lhs, AllocateParameters const& rhs) {
 }
 
 PretenureFlag PretenureFlagOf(const Operator* op) {
-  if (op->opcode() == IrOpcode::kNewFastDoubleElements ||
-      op->opcode() == IrOpcode::kNewFastSmiOrObjectElements) {
+  if (op->opcode() == IrOpcode::kNewDoubleElements ||
+      op->opcode() == IrOpcode::kNewSmiOrObjectElements) {
     return OpParameter<PretenureFlag>(op);
   }
   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
@@ -978,22 +978,22 @@ bool IsRestLengthOf(const Operator* op) {
   return OpParameter<ArgumentsLengthParameters>(op).is_rest_length;
 }
 
-const Operator* SimplifiedOperatorBuilder::NewFastDoubleElements(
+const Operator* SimplifiedOperatorBuilder::NewDoubleElements(
     PretenureFlag pretenure) {
   return new (zone()) Operator1<PretenureFlag>(  // --
-      IrOpcode::kNewFastDoubleElements,          // opcode
+      IrOpcode::kNewDoubleElements,              // opcode
       Operator::kEliminatable,                   // flags
-      "NewFastDoubleElements",                   // name
+      "NewDoubleElements",                       // name
       1, 1, 1, 1, 1, 0,                          // counts
       pretenure);                                // parameter
 }
 
-const Operator* SimplifiedOperatorBuilder::NewFastSmiOrObjectElements(
+const Operator* SimplifiedOperatorBuilder::NewSmiOrObjectElements(
     PretenureFlag pretenure) {
   return new (zone()) Operator1<PretenureFlag>(  // --
-      IrOpcode::kNewFastSmiOrObjectElements,     // opcode
+      IrOpcode::kNewSmiOrObjectElements,         // opcode
       Operator::kEliminatable,                   // flags
-      "NewFastSmiOrObjectElements",              // name
+      "NewSmiOrObjectElements",                  // name
       1, 1, 1, 1, 1, 0,                          // counts
       pretenure);                                // parameter
 }

src/compiler/simplified-operator.h

@@ -452,8 +452,8 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
   const Operator* ArgumentsLength(int formal_parameter_count,
                                   bool is_rest_length);
 
-  const Operator* NewFastDoubleElements(PretenureFlag);
-  const Operator* NewFastSmiOrObjectElements(PretenureFlag);
+  const Operator* NewDoubleElements(PretenureFlag);
+  const Operator* NewSmiOrObjectElements(PretenureFlag);
 
   // new-arguments-elements arguments-frame, arguments-length
   const Operator* NewArgumentsElements(int mapped_count);

src/compiler/typer.cc

@@ -2040,11 +2040,11 @@ Type* Typer::Visitor::TypeArgumentsFrame(Node* node) {
   return Type::ExternalPointer();
 }
 
-Type* Typer::Visitor::TypeNewFastDoubleElements(Node* node) {
+Type* Typer::Visitor::TypeNewDoubleElements(Node* node) {
   return Type::OtherInternal();
 }
 
-Type* Typer::Visitor::TypeNewFastSmiOrObjectElements(Node* node) {
+Type* Typer::Visitor::TypeNewSmiOrObjectElements(Node* node) {
   return Type::OtherInternal();
 }
 

src/compiler/verifier.cc

@@ -1042,8 +1042,8 @@ void Verifier::Visitor::Check(Node* node) {
     case IrOpcode::kArgumentsFrame:
       CheckTypeIs(node, Type::ExternalPointer());
       break;
-    case IrOpcode::kNewFastDoubleElements:
-    case IrOpcode::kNewFastSmiOrObjectElements:
+    case IrOpcode::kNewDoubleElements:
+    case IrOpcode::kNewSmiOrObjectElements:
       CheckValueInputIs(node, 0,
                         Type::Range(0.0, FixedArray::kMaxLength, zone));
       CheckTypeIs(node, Type::OtherInternal());