Support StringCharCodeAt in hydrogen/lithium.

src/hydrogen-instructions.h

 // Copyright 2010 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 63 matching lines @@
 //       HCompareJSObjectEq
 //       HInstanceOf
 //       HInstanceOfKnownGlobal
 //       HLoadKeyed
 //         HLoadKeyedFastElement
 //         HLoadKeyedGeneric
 //       HPower
 //       HStoreNamed
 //         HStoreNamedField
 //         HStoreNamedGeneric
+//       HStringCharCodeAt
 //     HBlockEntry
 //     HCall
 //       HCallConstantFunction
 //       HCallFunction
 //       HCallGlobal
 //       HCallKeyed
 //       HCallKnownGlobal
 //       HCallNamed
 //       HCallNew
 //       HCallRuntime
@@ skipping 36 matching lines @@
 //       HCheckSmi
 //       HDeleteProperty
 //       HFixedArrayLength
 //       HJSArrayLength
 //       HLoadElements
 //         HTypeofIs
 //       HLoadNamedField
 //       HLoadNamedGeneric
 //       HLoadFunctionPrototype
 //       HPushArgument
+//       HStringLength
 //       HTypeof
 //       HUnaryMathOperation
 //       HUnaryPredicate
 //         HClassOfTest
 //         HHasCachedArrayIndex
 //         HHasInstanceType
 //         HIsNull
 //         HIsObject
 //         HIsSmi
 //       HValueOf
@@ skipping 91 matching lines @@
   V(Sar)                                       \
   V(Shl)                                       \
   V(Shr)                                       \
   V(Simulate)                                  \
   V(StackCheck)                                \
   V(StoreGlobal)                               \
   V(StoreKeyedFastElement)                     \
   V(StoreKeyedGeneric)                         \
   V(StoreNamedField)                           \
   V(StoreNamedGeneric)                         \
+  V(StringCharCodeAt)                          \
+  V(StringLength)                              \
   V(Sub)                                       \
   V(Throw)                                     \
   V(Typeof)                                    \
   V(TypeofIs)                                  \
   V(UnaryMathOperation)                        \
   V(UnknownOSRValue)                           \
   V(ValueOf)
 
 #define GVN_FLAG_LIST(V)                       \
   V(Calls)                                     \
@@ skipping 1311 matching lines @@
 
 class HCheckInstanceType: public HUnaryOperation {
  public:
   // Check that the instance type is in the range [first, last] where
   // both first and last are included.
   HCheckInstanceType(HValue* value, InstanceType first, InstanceType last)
       : HUnaryOperation(value), first_(first), last_(last) {
     ASSERT(first <= last);
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
+    if ((FIRST_STRING_TYPE < first && last <= LAST_STRING_TYPE) ||
+        (FIRST_STRING_TYPE <= first && last < LAST_STRING_TYPE)) {
+      // A particular string instance type can change because of GC or
+      // externalization, but the value still remains a string.
+      SetFlag(kDependsOnMaps);
+    }
   }
 
   virtual bool IsCheckInstruction() const { return true; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
 #ifdef DEBUG
   virtual void Verify() const;
@@ skipping 1338 matching lines @@
  public:
   HStoreKeyedGeneric(HValue* obj, HValue* key, HValue* val)
       : HStoreKeyed(obj, key, val) {
     SetFlagMask(AllSideEffects());
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store_keyed_generic")
 };
 
 
+class HStringCharCodeAt: public HBinaryOperation {
+ public:
+  HStringCharCodeAt(HValue* string, HValue* index)
+      : HBinaryOperation(string, index) {
+    set_representation(Representation::Integer32());
+    SetFlag(kUseGVN);
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) const {
+    // The index is supposed to be Integer32.
+    return (index == 1) ? Representation::Integer32()
+        : Representation::Tagged();
+  }
+
+  virtual bool DataEquals(HValue* other) const { return true; }
+
+  HValue* string() const { return OperandAt(0); }
+  HValue* index() const { return OperandAt(1); }
+
+  DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string_char_code_at")
+
+ protected:
+  virtual Range* InferRange() {
+    return new Range(0, String::kMaxUC16CharCode);
+  }
+};
+
+
+class HStringLength: public HUnaryOperation {
+ public:
+  explicit HStringLength(HValue* string) : HUnaryOperation(string) {
+    set_representation(Representation::Tagged());
+    SetFlag(kUseGVN);
+  }
+
+  virtual Representation RequiredInputRepresentation(int index) const {
+    return Representation::Tagged();
+  }
+
+  virtual HType CalculateInferredType() const {
+    STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
+    return HType::Smi();
+  }
+
+  virtual bool DataEquals(HValue* other) const { return true; }
+
+  DECLARE_CONCRETE_INSTRUCTION(StringLength, "string_length")
+
+ protected:
+  virtual Range* InferRange() {
+    return new Range(0, String::kMaxLength);
+  }
+};
+
+
 class HMaterializedLiteral: public HInstruction {
  public:
   HMaterializedLiteral(int index, int depth)
       : literal_index_(index), depth_(depth) {
     set_representation(Representation::Tagged());
   }
 
   int literal_index() const { return literal_index_; }
   int depth() const { return depth_; }
 
@@ skipping 126 matching lines @@
   HValue* object() const { return left(); }
   HValue* key() const { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_