Fix opmitized external array access for compound assignments

src/ast.h

 // Copyright 2011 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 203 matching lines @@
     // Evaluated for its side effects.
     kEffect,
     // Evaluated for its value (and side effects).
     kValue,
     // Evaluated for control flow (and side effects).
     kTest
   };
 
   Expression() : bitfields_(0) {}
 
+  virtual int position() const {
+    UNREACHABLE();
+    return 0;
+  }
+
   virtual Expression* AsExpression()  { return this; }
 
   virtual bool IsTrivial() { return false; }
   virtual bool IsValidLeftHandSide() { return false; }
 
   // Helpers for ToBoolean conversion.
   virtual bool ToBooleanIsTrue() { return false; }
   virtual bool ToBooleanIsFalse() { return false; }
 
   // Symbols that cannot be parsed as array indices are considered property
@@ skipping 76 matching lines @@
   }
 
   // How many bitwise logical or shift operators are used in this expression?
   int num_bit_ops() { return NumBitOpsField::decode(bitfields_); }
   void set_num_bit_ops(int num_bit_ops) {
     bitfields_ &= ~NumBitOpsField::mask();
     num_bit_ops = Min(num_bit_ops, kMaxNumBitOps);
     bitfields_ |= NumBitOpsField::encode(num_bit_ops);
   }
 
+  ExternalArrayType external_array_type() const {
+    return ExternalArrayTypeField::decode(bitfields_);
+  }
+  void set_external_array_type(ExternalArrayType array_type) {
+    bitfields_ &= ~ExternalArrayTypeField::mask();
+    bitfields_ |= ExternalArrayTypeField::encode(array_type);
+  }
+
  private:
   static const int kMaxNumBitOps = (1 << 5) - 1;
 
   uint32_t bitfields_;
   StaticType type_;
 
   // Using template BitField<type, start, size>.
   class SideEffectFreeField : public BitField<bool, 0, 1> {};
   class NoNegativeZeroField : public BitField<bool, 1, 1> {};
   class ToInt32Field : public BitField<bool, 2, 1> {};
   class NumBitOpsField : public BitField<int, 3, 5> {};
   class LoopConditionField: public BitField<bool, 8, 1> {};
+  class ExternalArrayTypeField: public BitField<ExternalArrayType, 9, 4> {};
 };
 
 
 /**
  * A sentinel used during pre parsing that represents some expression
  * that is a valid left hand side without having to actually build
  * the expression.
  */
 class ValidLeftHandSideSentinel: public Expression {
  public:
@@ skipping 346 matching lines @@
   CaseClause(Expression* label, ZoneList<Statement*>* statements, int pos);
 
   bool is_default() const { return label_ == NULL; }
   Expression* label() const {
     CHECK(!is_default());
     return label_;
   }
   JumpTarget* body_target() { return &body_target_; }
   ZoneList<Statement*>* statements() const { return statements_; }
 
-  int position() { return position_; }
+  int position() const { return position_; }
   void set_position(int pos) { position_ = pos; }
 
   int EntryId() { return entry_id_; }
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   bool IsSmiCompare() { return compare_type_ == SMI_ONLY; }
   bool IsObjectCompare() { return compare_type_ == OBJECT_ONLY; }
 
  private:
@@ skipping 529 matching lines @@
         is_function_prototype_(false),
         is_arguments_access_(false) { }
 
   DECLARE_NODE_TYPE(Property)
 
   virtual bool IsValidLeftHandSide() { return true; }
   virtual bool IsInlineable() const;
 
   Expression* obj() const { return obj_; }
   Expression* key() const { return key_; }
-  int position() const { return pos_; }
+  virtual int position() const { return pos_; }
   bool is_synthetic() const { return type_ == SYNTHETIC; }
 
   bool IsStringLength() const { return is_string_length_; }
   bool IsStringAccess() const { return is_string_access_; }
   bool IsFunctionPrototype() const { return is_function_prototype_; }
 
   // Marks that this is actually an argument rewritten to a keyed property
   // accessing the argument through the arguments shadow object.
   void set_is_arguments_access(bool is_arguments_access) {
     is_arguments_access_ = is_arguments_access;
   }
   bool is_arguments_access() const { return is_arguments_access_; }
 
-  ExternalArrayType GetExternalArrayType() const { return array_type_; }
-  void SetExternalArrayType(ExternalArrayType array_type) {
-    array_type_ = array_type;
-  }
-
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   virtual ZoneMapList* GetReceiverTypes() { return receiver_types_; }
   virtual bool IsArrayLength() { return is_array_length_; }
   virtual Handle<Map> GetMonomorphicReceiverType() {
     return monomorphic_receiver_type_;
   }
 
  private:
   Expression* obj_;
   Expression* key_;
   int pos_;
   Type type_;
 
   ZoneMapList* receiver_types_;
   bool is_monomorphic_ : 1;
   bool is_array_length_ : 1;
   bool is_string_length_ : 1;
   bool is_string_access_ : 1;
   bool is_function_prototype_ : 1;
   bool is_arguments_access_ : 1;
   Handle<Map> monomorphic_receiver_type_;
-  ExternalArrayType array_type_;
 };
 
 
 class Call: public Expression {
  public:
   Call(Expression* expression, ZoneList<Expression*>* arguments, int pos)
       : expression_(expression),
         arguments_(arguments),
         pos_(pos),
         is_monomorphic_(false),
         check_type_(RECEIVER_MAP_CHECK),
         receiver_types_(NULL),
         return_id_(GetNextId()) {
   }
 
   DECLARE_NODE_TYPE(Call)
 
   virtual bool IsInlineable() const;
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
-  int position() { return pos_; }
+  virtual int position() const { return pos_; }
 
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual ZoneMapList* GetReceiverTypes() { return receiver_types_; }
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   CheckType check_type() const { return check_type_; }
   Handle<JSFunction> target() { return target_; }
   Handle<JSObject> holder() { return holder_; }
   Handle<JSGlobalPropertyCell> cell() { return cell_; }
 
   bool ComputeTarget(Handle<Map> type, Handle<String> name);
@@ skipping 57 matching lines @@
  public:
   CallNew(Expression* expression, ZoneList<Expression*>* arguments, int pos)
       : expression_(expression), arguments_(arguments), pos_(pos) { }
 
   DECLARE_NODE_TYPE(CallNew)
 
   virtual bool IsInlineable() const;
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
-  int position() { return pos_; }
+  virtual int position() const { return pos_; }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
@@ skipping 62 matching lines @@
 
   DECLARE_NODE_TYPE(BinaryOperation)
 
   virtual bool IsInlineable() const;
 
   virtual bool ResultOverwriteAllowed();
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
-  int position() const { return pos_; }
+  virtual int position() const { return pos_; }
 
   // Bailout support.
   int RightId() const { return right_id_; }
 
  private:
   Token::Value op_;
   Expression* left_;
   Expression* right_;
   int pos_;
   // The short-circuit logical operations have an AST ID for their
@@ skipping 16 matching lines @@
 
   bool is_prefix() const { return is_prefix_; }
   bool is_postfix() const { return !is_prefix_; }
 
   Token::Value op() const { return op_; }
   Token::Value binary_op() {
     return (op() == Token::INC) ? Token::ADD : Token::SUB;
   }
 
   Expression* expression() const { return expression_; }
-  int position() const { return pos_; }
+  virtual int position() const { return pos_; }
 
   virtual void MarkAsStatement() { is_prefix_ = true; }
 
   virtual bool IsInlineable() const;
 
+  void RecordTypeFeedback(TypeFeedbackOracle* oracle);
+  virtual bool IsMonomorphic() { return is_monomorphic_; }
+  virtual Handle<Map> GetMonomorphicReceiverType() {
+    return monomorphic_receiver_type_;
+  }
+
   // Bailout support.
   int AssignmentId() const { return assignment_id_; }
   int CountId() const { return count_id_; }
 
  private:
   Token::Value op_;
   bool is_prefix_;
+  bool is_monomorphic_;
   Expression* expression_;
   int pos_;
   int assignment_id_;
   int count_id_;
+  Handle<Map> monomorphic_receiver_type_;
 };
 
 
 class CompareOperation: public Expression {
  public:
   CompareOperation(Token::Value op,
                    Expression* left,
                    Expression* right,
                    int pos)
       : op_(op), left_(left), right_(right), pos_(pos), compare_type_(NONE) {
     ASSERT(Token::IsCompareOp(op));
   }
 
   DECLARE_NODE_TYPE(CompareOperation)
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
-  int position() const { return pos_; }
+  virtual int position() const { return pos_; }
 
   virtual bool IsInlineable() const;
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   bool IsSmiCompare() { return compare_type_ == SMI_ONLY; }
   bool IsObjectCompare() { return compare_type_ == OBJECT_ONLY; }
 
  private:
   Token::Value op_;
@@ skipping 74 matching lines @@
 
   virtual bool IsInlineable() const;
 
   Assignment* AsSimpleAssignment() { return !is_compound() ? this : NULL; }
 
   Token::Value binary_op() const;
 
   Token::Value op() const { return op_; }
   Expression* target() const { return target_; }
   Expression* value() const { return value_; }
-  int position() { return pos_; }
+  virtual int position() const { return pos_; }
   BinaryOperation* binary_operation() const { return binary_operation_; }
 
   // This check relies on the definition order of token in token.h.
   bool is_compound() const { return op() > Token::ASSIGN; }
 
   // An initialization block is a series of statments of the form
   // x.y.z.a = ...; x.y.z.b = ...; etc. The parser marks the beginning and
   // ending of these blocks to allow for optimizations of initialization
   // blocks.
   bool starts_initialization_block() { return block_start_; }
   bool ends_initialization_block() { return block_end_; }
   void mark_block_start() { block_start_ = true; }
   void mark_block_end() { block_end_ = true; }
 
   // Type feedback information.
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   virtual ZoneMapList* GetReceiverTypes() { return receiver_types_; }
   virtual Handle<Map> GetMonomorphicReceiverType() {
     return monomorphic_receiver_type_;
   }
-  ExternalArrayType GetExternalArrayType() const { return array_type_; }
-  void SetExternalArrayType(ExternalArrayType array_type) {
-    array_type_ = array_type;
-  }
 
   // Bailout support.
   int CompoundLoadId() const { return compound_load_id_; }
   int AssignmentId() const { return assignment_id_; }
 
  private:
   Token::Value op_;
   Expression* target_;
   Expression* value_;
   int pos_;
   BinaryOperation* binary_operation_;
   int compound_load_id_;
   int assignment_id_;
 
   bool block_start_;
   bool block_end_;
 
   bool is_monomorphic_;
   ZoneMapList* receiver_types_;
   Handle<Map> monomorphic_receiver_type_;
-  ExternalArrayType array_type_;
 };
 
 
 class Throw: public Expression {
  public:
   Throw(Expression* exception, int pos)
       : exception_(exception), pos_(pos) {}
 
   DECLARE_NODE_TYPE(Throw)
 
   Expression* exception() const { return exception_; }
-  int position() const { return pos_; }
+  virtual int position() const { return pos_; }
 
  private:
   Expression* exception_;
   int pos_;
 };
 
 
 class FunctionLiteral: public Expression {
  public:
   FunctionLiteral(Handle<String> name,
@@ skipping 500 matching lines @@
 
  private:
   Isolate* isolate_;
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_