[turbofan] inline %StringIteratorPrototype%.next in JSBuiltinReducer.

src/compiler/simplified-operator.cc

 // 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.
 
 #include "src/compiler/simplified-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/types.h"
@@ skipping 319 matching lines @@
          op->opcode() == IrOpcode::kSpeculativeNumberLessThan ||
          op->opcode() == IrOpcode::kSpeculativeNumberLessThanOrEqual);
   return OpParameter<NumberOperationHint>(op);
 }
 
 PretenureFlag PretenureFlagOf(const Operator* op) {
   DCHECK_EQ(IrOpcode::kAllocate, op->opcode());
   return OpParameter<PretenureFlag>(op);
 }
 
+StringOperationHint StringOperationHintOf(const Operator* op) {
+  DCHECK(op->opcode() == IrOpcode::kStringCharCodeAt);
+  return OpParameter<StringOperationHint>(op);
+}
+
+UnicodeEncoding UnicodeEncodingOf(const Operator* op) {
+  DCHECK(op->opcode() == IrOpcode::kStringFromCodePoint);
+  return OpParameter<UnicodeEncoding>(op);
+}
+
 #define PURE_OP_LIST(V)                                          \
   V(BooleanNot, Operator::kNoProperties, 1, 0)                   \
   V(NumberEqual, Operator::kCommutative, 2, 0)                   \
   V(NumberLessThan, Operator::kNoProperties, 2, 0)               \
   V(NumberLessThanOrEqual, Operator::kNoProperties, 2, 0)        \
   V(NumberAdd, Operator::kCommutative, 2, 0)                     \
   V(NumberSubtract, Operator::kNoProperties, 2, 0)               \
   V(NumberMultiply, Operator::kCommutative, 2, 0)                \
   V(NumberDivide, Operator::kNoProperties, 2, 0)                 \
   V(NumberModulus, Operator::kNoProperties, 2, 0)                \
@@ skipping 33 matching lines @@
   V(NumberSin, Operator::kNoProperties, 1, 0)                    \
   V(NumberSinh, Operator::kNoProperties, 1, 0)                   \
   V(NumberSqrt, Operator::kNoProperties, 1, 0)                   \
   V(NumberTan, Operator::kNoProperties, 1, 0)                    \
   V(NumberTanh, Operator::kNoProperties, 1, 0)                   \
   V(NumberTrunc, Operator::kNoProperties, 1, 0)                  \
   V(NumberToBoolean, Operator::kNoProperties, 1, 0)              \
   V(NumberToInt32, Operator::kNoProperties, 1, 0)                \
   V(NumberToUint32, Operator::kNoProperties, 1, 0)               \
   V(NumberSilenceNaN, Operator::kNoProperties, 1, 0)             \
-  V(StringCharCodeAt, Operator::kNoProperties, 2, 1)             \
   V(StringFromCharCode, Operator::kNoProperties, 1, 0)           \
   V(PlainPrimitiveToNumber, Operator::kNoProperties, 1, 0)       \
   V(PlainPrimitiveToWord32, Operator::kNoProperties, 1, 0)       \
   V(PlainPrimitiveToFloat64, Operator::kNoProperties, 1, 0)      \
   V(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1, 0)    \
   V(ChangeTaggedToInt32, Operator::kNoProperties, 1, 0)          \
   V(ChangeTaggedToUint32, Operator::kNoProperties, 1, 0)         \
   V(ChangeTaggedToFloat64, Operator::kNoProperties, 1, 0)        \
   V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1, 0)    \
   V(ChangeInt32ToTagged, Operator::kNoProperties, 1, 0)          \
@@ skipping 57 matching lines @@
   struct Name##Operator final : public Operator {                        \
     Name##Operator()                                                     \
         : Operator(IrOpcode::k##Name,                                    \
                    Operator::kFoldable | Operator::kNoThrow, #Name,      \
                    value_input_count, 1, 1, value_output_count, 1, 0) {} \
   };                                                                     \
   Name##Operator k##Name;
   CHECKED_OP_LIST(CHECKED)
 #undef CHECKED
 
+  template <StringOperationHint kHint>
+  struct StringCharCodeAtOperator final : public Operator {
+    StringCharCodeAtOperator()
+        : Operator(IrOpcode::kStringCharCodeAt, Operator::kPure,
+                   "StringCharCodeAt", 2, 0, 1, 1, 0, 0) {}
+  };
+  StringCharCodeAtOperator<StringOperationHint::kAny>
+      kStringCharCodeAtOperatorAny;
+  StringCharCodeAtOperator<StringOperationHint::kSeqStringOrExternalString>
+      kStringCharCodeAtOperatorSeqStringOrExternalString;
+
+  template <UnicodeEncoding kEncoding>
+  struct StringFromCodePointOperator final : public Operator {
+    StringFromCodePointOperator()
+        : Operator(IrOpcode::kStringFromCodePoint, Operator::kPure,
+                   "StringFromCodePoint", 1, 0, 0, 1, 0, 0) {}
+  };
+  StringFromCodePointOperator<UnicodeEncoding::UTF16>
+      kStringFromCodePointOperatorUTF16;
+  StringFromCodePointOperator<UnicodeEncoding::UTF32>
+      kStringFromCodePointOperatorUTF32;
+
   struct ArrayBufferWasNeuteredOperator final : public Operator {
     ArrayBufferWasNeuteredOperator()
         : Operator(IrOpcode::kArrayBufferWasNeutered, Operator::kEliminatable,
                    "ArrayBufferWasNeutered", 1, 1, 1, 1, 1, 0) {}
   };
   ArrayBufferWasNeuteredOperator kArrayBufferWasNeutered;
 
   template <CheckForMinusZeroMode kMode>
   struct ChangeFloat64ToTaggedOperator final
       : public Operator1<CheckForMinusZeroMode> {
@@ skipping 291 matching lines @@
 #define STORE_BUFFER(Type, type, TYPE, ctype, size) \
   case kExternal##Type##Array:                      \
     return &cache_.kStoreBuffer##Type;
     TYPED_ARRAYS(STORE_BUFFER)
 #undef STORE_BUFFER
   }
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* SimplifiedOperatorBuilder::StringCharCodeAt(
+    StringOperationHint hint) {
+  switch (hint) {
+    case StringOperationHint::kAny:
+      return &cache_.kStringCharCodeAtOperatorAny;
+    case StringOperationHint::kSeqStringOrExternalString:
+      return &cache_.kStringCharCodeAtOperatorSeqStringOrExternalString;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
+const Operator* SimplifiedOperatorBuilder::StringFromCodePoint(
+    UnicodeEncoding encoding) {
+  switch (encoding) {
+    case UnicodeEncoding::UTF16:
+      return &cache_.kStringFromCodePointOperatorUTF16;
+    case UnicodeEncoding::UTF32:
+      return &cache_.kStringFromCodePointOperatorUTF32;
+  }
+  UNREACHABLE();
+  return nullptr;
+}
+
 #define SPECULATIVE_NUMBER_BINOP(Name)                                        \
   const Operator* SimplifiedOperatorBuilder::Name(NumberOperationHint hint) { \
     switch (hint) {                                                           \
       case NumberOperationHint::kSignedSmall:                                 \
         return &cache_.k##Name##SignedSmallOperator;                          \
       case NumberOperationHint::kSigned32:                                    \
         return &cache_.k##Name##Signed32Operator;                             \
       case NumberOperationHint::kNumber:                                      \
         return &cache_.k##Name##NumberOperator;                               \
       case NumberOperationHint::kNumberOrOddball:                             \
@@ skipping 21 matching lines @@
                         Operator::kNoDeopt | Operator::kNoThrow | properties,  \
                         #Name, value_input_count, 1, control_input_count,      \
                         output_count, 1, 0, access);                           \
   }
 ACCESS_OP_LIST(ACCESS)
 #undef ACCESS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8