A64: Synchronize with r15204.

src/ast.cc

 // 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 485 matching lines @@
   } else if (oracle->StoreIsPolymorphic(id)) {
     receiver_types_.Reserve(kMaxKeyedPolymorphism, zone);
     oracle->CollectKeyedReceiverTypes(id, &receiver_types_);
   }
   store_mode_ = oracle->GetStoreMode(id);
   type_ = oracle->IncrementType(this);
 }
 
 
 void CaseClause::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
-  TypeInfo info = oracle->SwitchType(this);
-  if (info.IsUninitialized()) info = TypeInfo::Unknown();
-  if (info.IsSmi()) {
-    compare_type_ = SMI_ONLY;
-  } else if (info.IsInternalizedString()) {
-    compare_type_ = NAME_ONLY;
-  } else if (info.IsNonInternalizedString()) {
-    compare_type_ = STRING_ONLY;
-  } else if (info.IsNonPrimitive()) {
-    compare_type_ = OBJECT_ONLY;
-  } else {
-    ASSERT(compare_type_ == NONE);
-  }
+  compare_type_ = oracle->ClauseType(CompareId());
 }
 
 
 bool Call::ComputeTarget(Handle<Map> type, Handle<String> name) {
   // If there is an interceptor, we can't compute the target for a direct call.
   if (type->has_named_interceptor()) return false;
 
   if (check_type_ == RECEIVER_MAP_CHECK) {
     // For primitive checks the holder is set up to point to the corresponding
     // prototype object, i.e. one step of the algorithm below has been already
@@ skipping 34 matching lines @@
     // Go up the prototype chain, recording where we are currently.
     holder_ = Handle<JSObject>(JSObject::cast(type->prototype()));
     type = Handle<Map>(holder()->map());
   }
 }
 
 
 bool Call::ComputeGlobalTarget(Handle<GlobalObject> global,
                                LookupResult* lookup) {
   target_ = Handle<JSFunction>::null();
-  cell_ = Handle<JSGlobalPropertyCell>::null();
+  cell_ = Handle<Cell>::null();
   ASSERT(lookup->IsFound() &&
          lookup->type() == NORMAL &&
          lookup->holder() == *global);
-  cell_ = Handle<JSGlobalPropertyCell>(global->GetPropertyCell(lookup));
+  cell_ = Handle<Cell>(global->GetPropertyCell(lookup));
   if (cell_->value()->IsJSFunction()) {
     Handle<JSFunction> candidate(JSFunction::cast(cell_->value()));
     // If the function is in new space we assume it's more likely to
     // change and thus prefer the general IC code.
     if (!HEAP->InNewSpace(*candidate)) {
       target_ = candidate;
       return true;
     }
   }
   return false;
@@ skipping 80 matching lines @@
 
 
 void ObjectLiteral::Property::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
   receiver_type_ = oracle->ObjectLiteralStoreIsMonomorphic(this)
       ? oracle->GetObjectLiteralStoreMap(this)
       : Handle<Map>::null();
 }
 
 
 void UnaryOperation::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
-  type_ = oracle->UnaryType(this);
+  type_ = oracle->UnaryType(UnaryOperationFeedbackId());
 }
 
 
 void BinaryOperation::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
-  oracle->BinaryType(this, &left_type_, &right_type_, &result_type_,
+  oracle->BinaryType(BinaryOperationFeedbackId(),
+                     &left_type_, &right_type_, &result_type_,
                      &has_fixed_right_arg_, &fixed_right_arg_value_);
 }
 
 
+// TODO(rossberg): this function (and all other RecordTypeFeedback functions)
+// should disappear once we use the common type field in the AST consistently.
 void CompareOperation::RecordTypeFeedback(TypeFeedbackOracle* oracle) {
-  oracle->CompareType(this, &left_type_, &right_type_, &overall_type_);
-  if (!overall_type_.IsUninitialized() && overall_type_.IsNonPrimitive() &&
-      (op_ == Token::EQ || op_ == Token::EQ_STRICT)) {
-    map_ = oracle->GetCompareMap(this);
-  } else {
-    // May be a compare to nil.
-    map_ = oracle->CompareNilMonomorphicReceiverType(this);
-    if (op_ != Token::EQ_STRICT)
-      compare_nil_types_ = oracle->CompareNilTypes(this);
-  }
+  oracle->CompareTypes(CompareOperationFeedbackId(),
+      &left_type_, &right_type_, &overall_type_, &compare_nil_type_);
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of AstVisitor
 
 void AstVisitor::VisitDeclarations(ZoneList<Declaration*>* declarations) {
   for (int i = 0; i < declarations->length(); i++) {
     Visit(declarations->at(i));
   }
@@ skipping 356 matching lines @@
 }
 
 
 CaseClause::CaseClause(Isolate* isolate,
                        Expression* label,
                        ZoneList<Statement*>* statements,
                        int pos)
     : label_(label),
       statements_(statements),
       position_(pos),
-      compare_type_(NONE),
+      compare_type_(Type::None(), isolate),
       compare_id_(AstNode::GetNextId(isolate)),
       entry_id_(AstNode::GetNextId(isolate)) {
 }
 
 
 #define REGULAR_NODE(NodeType) \
   void AstConstructionVisitor::Visit##NodeType(NodeType* node) { \
     increase_node_count(); \
   }
 #define DONT_OPTIMIZE_NODE(NodeType) \
@@ skipping 107 matching lines @@
     OS::SNPrintF(buffer, "%d", Smi::cast(*handle_)->value());
     str = arr;
   } else {
     str = DoubleToCString(handle_->Number(), buffer);
   }
   return factory->NewStringFromAscii(CStrVector(str));
 }
 
 
 } }  // namespace v8::internal