A64: Synchronize with r15204.

src/ast.h

 // Copyright 2012 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 340 matching lines @@
   bool IsStringLiteral();
 
   // True iff the expression is the null literal.
   bool IsNullLiteral();
 
   // True iff the expression is the undefined literal.
   bool IsUndefinedLiteral();
 
   // Expression type
   Handle<Type> type() { return type_; }
+  void set_type(Handle<Type> type) { type_ = type; }
 
   // Type feedback information for assignments and properties.
   virtual bool IsMonomorphic() {
     UNREACHABLE();
     return false;
   }
   virtual SmallMapList* GetReceiverTypes() {
     UNREACHABLE();
     return NULL;
   }
@@ skipping 10 matching lines @@
 
   // TODO(rossberg): this should move to its own AST node eventually.
   void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
   byte to_boolean_types() const { return to_boolean_types_; }
 
   BailoutId id() const { return id_; }
   TypeFeedbackId test_id() const { return test_id_; }
 
  protected:
   explicit Expression(Isolate* isolate)
-      : type_(Type::Any(), isolate),
+      : type_(Type::None(), isolate),
         id_(GetNextId(isolate)),
         test_id_(GetNextId(isolate)) {}
 
  private:
   Handle<Type> type_;
   byte to_boolean_types_;
 
   const BailoutId id_;
   const TypeFeedbackId test_id_;
 };
@@ skipping 697 matching lines @@
   ZoneList<Statement*>* statements() const { return statements_; }
 
   int position() const { return position_; }
   void set_position(int pos) { position_ = pos; }
 
   BailoutId EntryId() const { return entry_id_; }
 
   // Type feedback information.
   TypeFeedbackId CompareId() { return compare_id_; }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
-  bool IsSmiCompare() { return compare_type_ == SMI_ONLY; }
-  bool IsNameCompare() { return compare_type_ == NAME_ONLY; }
-  bool IsStringCompare() { return compare_type_ == STRING_ONLY; }
-  bool IsObjectCompare() { return compare_type_ == OBJECT_ONLY; }
+  Handle<Type> compare_type() { return compare_type_; }
 
  private:
   Expression* label_;
   Label body_target_;
   ZoneList<Statement*>* statements_;
   int position_;
-  enum CompareTypeFeedback {
-    NONE,
-    SMI_ONLY,
-    NAME_ONLY,
-    STRING_ONLY,
-    OBJECT_ONLY
-  };
-  CompareTypeFeedback compare_type_;
+  Handle<Type> compare_type_;
+
   const TypeFeedbackId compare_id_;
   const BailoutId entry_id_;
 };
 
 
 class SwitchStatement: public BreakableStatement {
  public:
   DECLARE_NODE_TYPE(SwitchStatement)
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
@@ skipping 561 matching lines @@
     check_type_ = RECEIVER_MAP_CHECK;
   }
 
   Handle<JSFunction> target() { return target_; }
 
   // A cache for the holder, set as a side effect of computing the target of the
   // call. Note that it contains the null handle when the receiver is the same
   // as the holder!
   Handle<JSObject> holder() { return holder_; }
 
-  Handle<JSGlobalPropertyCell> cell() { return cell_; }
+  Handle<Cell> cell() { return cell_; }
 
   bool ComputeTarget(Handle<Map> type, Handle<String> name);
   bool ComputeGlobalTarget(Handle<GlobalObject> global, LookupResult* lookup);
 
   BailoutId ReturnId() const { return return_id_; }
 
   // TODO(rossberg): this should really move somewhere else (and be merged with
   // various similar methods in objets.cc), but for now...
   static Handle<JSObject> GetPrototypeForPrimitiveCheck(
       CheckType check, Isolate* isolate);
@@ skipping 19 matching lines @@
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 
   bool is_monomorphic_;
   CheckType check_type_;
   SmallMapList receiver_types_;
   Handle<JSFunction> target_;
   Handle<JSObject> holder_;
-  Handle<JSGlobalPropertyCell> cell_;
+  Handle<Cell> cell_;
 
   const BailoutId return_id_;
 };
 
 
 class CallNew: public Expression {
  public:
   DECLARE_NODE_TYPE(CallNew)
 
   Expression* expression() const { return expression_; }
   ZoneList<Expression*>* arguments() const { return arguments_; }
   virtual int position() const { return pos_; }
 
   // Type feedback information.
   TypeFeedbackId CallNewFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
   virtual bool IsMonomorphic() { return is_monomorphic_; }
   Handle<JSFunction> target() const { return target_; }
   ElementsKind elements_kind() const { return elements_kind_; }
-  Handle<JSGlobalPropertyCell> allocation_info_cell() const {
+  Handle<Cell> allocation_info_cell() const {
     return allocation_info_cell_;
   }
 
   BailoutId ReturnId() const { return return_id_; }
 
  protected:
   CallNew(Isolate* isolate,
           Expression* expression,
           ZoneList<Expression*>* arguments,
           int pos)
       : Expression(isolate),
         expression_(expression),
         arguments_(arguments),
         pos_(pos),
         is_monomorphic_(false),
         elements_kind_(GetInitialFastElementsKind()),
         return_id_(GetNextId(isolate)) { }
 
  private:
   Expression* expression_;
   ZoneList<Expression*>* arguments_;
   int pos_;
 
   bool is_monomorphic_;
   Handle<JSFunction> target_;
   ElementsKind elements_kind_;
-  Handle<JSGlobalPropertyCell> allocation_info_cell_;
+  Handle<Cell> allocation_info_cell_;
 
   const BailoutId return_id_;
 };
 
 
 // The CallRuntime class does not represent any official JavaScript
 // language construct. Instead it is used to call a C or JS function
 // with a set of arguments. This is used from the builtins that are
 // implemented in JavaScript (see "v8natives.js").
 class CallRuntime: public Expression {
@@ skipping 32 matching lines @@
 
   Token::Value op() const { return op_; }
   Expression* expression() const { return expression_; }
   virtual int position() const { return pos_; }
 
   BailoutId MaterializeTrueId() { return materialize_true_id_; }
   BailoutId MaterializeFalseId() { return materialize_false_id_; }
 
   TypeFeedbackId UnaryOperationFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
-  TypeInfo type() const { return type_; }
+  Handle<Type> type() const { return type_; }
 
  protected:
   UnaryOperation(Isolate* isolate,
                  Token::Value op,
                  Expression* expression,
                  int pos)
       : Expression(isolate),
         op_(op),
         expression_(expression),
         pos_(pos),
         materialize_true_id_(GetNextId(isolate)),
         materialize_false_id_(GetNextId(isolate)) {
     ASSERT(Token::IsUnaryOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* expression_;
   int pos_;
 
-  TypeInfo type_;
+  Handle<Type> type_;
 
   // For unary not (Token::NOT), the AST ids where true and false will
   // actually be materialized, respectively.
   const BailoutId materialize_true_id_;
   const BailoutId materialize_false_id_;
 };
 
 
 class BinaryOperation: public Expression {
  public:
   DECLARE_NODE_TYPE(BinaryOperation)
 
   virtual bool ResultOverwriteAllowed();
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   virtual int position() const { return pos_; }
 
   BailoutId RightId() const { return right_id_; }
 
   TypeFeedbackId BinaryOperationFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
-  TypeInfo left_type() const { return left_type_; }
-  TypeInfo right_type() const { return right_type_; }
-  TypeInfo result_type() const { return result_type_; }
+  Handle<Type> left_type() const { return left_type_; }
+  Handle<Type> right_type() const { return right_type_; }
+  Handle<Type> result_type() const { return result_type_; }
   bool has_fixed_right_arg() const { return has_fixed_right_arg_; }
   int fixed_right_arg_value() const { return fixed_right_arg_value_; }
 
  protected:
   BinaryOperation(Isolate* isolate,
                   Token::Value op,
                   Expression* left,
                   Expression* right,
                   int pos)
       : Expression(isolate),
         op_(op),
         left_(left),
         right_(right),
         pos_(pos),
         right_id_(GetNextId(isolate)) {
     ASSERT(Token::IsBinaryOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* left_;
   Expression* right_;
   int pos_;
 
-  TypeInfo left_type_;
-  TypeInfo right_type_;
-  TypeInfo result_type_;
+  Handle<Type> left_type_;
+  Handle<Type> right_type_;
+  Handle<Type> result_type_;
   bool has_fixed_right_arg_;
   int fixed_right_arg_value_;
 
   // The short-circuit logical operations need an AST ID for their
   // right-hand subexpression.
   const BailoutId right_id_;
 };
 
 
 class CountOperation: public Expression {
@@ skipping 63 matching lines @@
   DECLARE_NODE_TYPE(CompareOperation)
 
   Token::Value op() const { return op_; }
   Expression* left() const { return left_; }
   Expression* right() const { return right_; }
   virtual int position() const { return pos_; }
 
   // Type feedback information.
   TypeFeedbackId CompareOperationFeedbackId() const { return reuse(id()); }
   void RecordTypeFeedback(TypeFeedbackOracle* oracle);
-  TypeInfo left_type() const { return left_type_; }
-  TypeInfo right_type() const { return right_type_; }
-  TypeInfo overall_type() const { return overall_type_; }
-  byte compare_nil_types() const { return compare_nil_types_; }
-  Handle<Map> map() const { return map_; }
+  Handle<Type> left_type() const { return left_type_; }
+  Handle<Type> right_type() const { return right_type_; }
+  Handle<Type> overall_type() const { return overall_type_; }
+  Handle<Type> compare_nil_type() const { return compare_nil_type_; }
 
   // Match special cases.
   bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
   bool IsLiteralCompareUndefined(Expression** expr);
   bool IsLiteralCompareNull(Expression** expr);
 
  protected:
   CompareOperation(Isolate* isolate,
                    Token::Value op,
                    Expression* left,
                    Expression* right,
                    int pos)
       : Expression(isolate),
         op_(op),
         left_(left),
         right_(right),
         pos_(pos) {
     ASSERT(Token::IsCompareOp(op));
   }
 
  private:
   Token::Value op_;
   Expression* left_;
   Expression* right_;
   int pos_;
 
-  TypeInfo left_type_;
-  TypeInfo right_type_;
-  TypeInfo overall_type_;
-  byte compare_nil_types_;
-  Handle<Map> map_;
+  Handle<Type> left_type_;
+  Handle<Type> right_type_;
+  Handle<Type> overall_type_;
+  Handle<Type> compare_nil_type_;
 };
 
 
 class Conditional: public Expression {
  public:
   DECLARE_NODE_TYPE(Conditional)
 
   Expression* condition() const { return condition_; }
   Expression* then_expression() const { return then_expression_; }
   Expression* else_expression() const { return else_expression_; }
@@ skipping 1176 matching lines @@
  private:
   Isolate* isolate_;
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_