A64: Synchronize with r15358.

src/ic.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 2419 matching lines @@
   UNREACHABLE();
   return v8::internal::UNINITIALIZED;
 }
 
 
 Handle<Type> UnaryOpIC::TypeInfoToType(TypeInfo type_info, Isolate* isolate) {
   switch (type_info) {
     case UNINITIALIZED:
       return handle(Type::None(), isolate);
     case SMI:
-      return handle(Type::Integer31(), isolate);
+      return handle(Type::Smi(), isolate);
     case NUMBER:
       return handle(Type::Number(), isolate);
     case GENERIC:
       return handle(Type::Any(), isolate);
   }
   UNREACHABLE();
   return handle(Type::Any(), isolate);
 }
 
 
@@ skipping 66 matching lines @@
   return ::v8::internal::UNINITIALIZED;
 }
 
 
 Handle<Type> BinaryOpIC::TypeInfoToType(BinaryOpIC::TypeInfo binary_type,
                                         Isolate* isolate) {
   switch (binary_type) {
     case UNINITIALIZED:
       return handle(Type::None(), isolate);
     case SMI:
-      return handle(Type::Integer31(), isolate);
+      return handle(Type::Smi(), isolate);
     case INT32:
-      return handle(Type::Integer32(), isolate);
+      return handle(Type::Signed32(), isolate);
     case NUMBER:
       return handle(Type::Number(), isolate);
     case ODDBALL:
       return handle(Type::Optional(
           handle(Type::Union(
               handle(Type::Number(), isolate),
               handle(Type::String(), isolate)), isolate)), isolate);
     case STRING:
       return handle(Type::String(), isolate);
     case GENERIC:
@@ skipping 106 matching lines @@
     if (new_type == BinaryOpIC::STRING) return new_type;
     return BinaryOpIC::GENERIC;
   }
   return Max(old_type, new_type);
 }
 
 
 #ifdef DEBUG
 static void TraceBinaryOp(BinaryOpIC::TypeInfo left,
                           BinaryOpIC::TypeInfo right,
-                          bool has_fixed_right_arg,
-                          int32_t fixed_right_arg_value,
+                          Maybe<int32_t> fixed_right_arg,
                           BinaryOpIC::TypeInfo result) {
   PrintF("%s*%s", BinaryOpIC::GetName(left), BinaryOpIC::GetName(right));
-  if (has_fixed_right_arg) PrintF("{%d}", fixed_right_arg_value);
+  if (fixed_right_arg.has_value) PrintF("{%d}", fixed_right_arg.value);
   PrintF("->%s", BinaryOpIC::GetName(result));
 }
 #endif
 
 
 RUNTIME_FUNCTION(MaybeObject*, BinaryOp_Patch) {
   ASSERT(args.length() == 3);
 
   HandleScope scope(isolate);
   Handle<Object> left = args.at<Object>(0);
@@ skipping 11 matching lines @@
 
   // STRING is only used for ADD operations.
   if ((new_left == BinaryOpIC::STRING || new_right == BinaryOpIC::STRING) &&
       op != Token::ADD) {
     new_left = new_right = BinaryOpIC::GENERIC;
   }
 
   BinaryOpIC::TypeInfo new_overall = Max(new_left, new_right);
   BinaryOpIC::TypeInfo previous_overall = Max(previous_left, previous_right);
 
-  bool previous_has_fixed_right_arg =
-      BinaryOpStub::decode_has_fixed_right_arg_from_minor_key(key);
-  int previous_fixed_right_arg_value =
-      BinaryOpStub::decode_fixed_right_arg_value_from_minor_key(key);
+  Maybe<int> previous_fixed_right_arg =
+      BinaryOpStub::decode_fixed_right_arg_from_minor_key(key);
 
   int32_t value;
   bool new_has_fixed_right_arg =
       op == Token::MOD &&
       right->ToInt32(&value) &&
       BinaryOpStub::can_encode_arg_value(value) &&
       (previous_overall == BinaryOpIC::UNINITIALIZED ||
-       (previous_has_fixed_right_arg &&
-        previous_fixed_right_arg_value == value));
-  int32_t new_fixed_right_arg_value = new_has_fixed_right_arg ? value : 1;
+       (previous_fixed_right_arg.has_value &&
+        previous_fixed_right_arg.value == value));
+  Maybe<int32_t> new_fixed_right_arg(
+      new_has_fixed_right_arg, new_has_fixed_right_arg ? value : 1);
 
-  if (previous_has_fixed_right_arg == new_has_fixed_right_arg) {
+  if (previous_fixed_right_arg.has_value == new_fixed_right_arg.has_value) {
     if (new_overall == BinaryOpIC::SMI && previous_overall == BinaryOpIC::SMI) {
       if (op == Token::DIV ||
           op == Token::MUL ||
           op == Token::SHR ||
           kSmiValueSize == 32) {
         // Arithmetic on two Smi inputs has yielded a heap number.
         // That is the only way to get here from the Smi stub.
         // With 32-bit Smis, all overflows give heap numbers, but with
         // 31-bit Smis, most operations overflow to int32 results.
         result_type = BinaryOpIC::NUMBER;
       } else {
         // Other operations on SMIs that overflow yield int32s.
         result_type = BinaryOpIC::INT32;
       }
     }
     if (new_overall == BinaryOpIC::INT32 &&
         previous_overall == BinaryOpIC::INT32) {
       if (new_left == previous_left && new_right == previous_right) {
         result_type = BinaryOpIC::NUMBER;
       }
     }
   }
 
-  BinaryOpStub stub(key, new_left, new_right, result_type,
-                    new_has_fixed_right_arg, new_fixed_right_arg_value);
+  BinaryOpStub stub(key, new_left, new_right, result_type, new_fixed_right_arg);
   Handle<Code> code = stub.GetCode(isolate);
   if (!code.is_null()) {
 #ifdef DEBUG
     if (FLAG_trace_ic) {
       PrintF("[BinaryOpIC in ");
       JavaScriptFrame::PrintTop(isolate, stdout, false, true);
       PrintF(" ");
-      TraceBinaryOp(previous_left, previous_right, previous_has_fixed_right_arg,
-                    previous_fixed_right_arg_value, previous_result);
+      TraceBinaryOp(previous_left, previous_right, previous_fixed_right_arg,
+                    previous_result);
       PrintF(" => ");
-      TraceBinaryOp(new_left, new_right, new_has_fixed_right_arg,
-                    new_fixed_right_arg_value, result_type);
+      TraceBinaryOp(new_left, new_right, new_fixed_right_arg, result_type);
       PrintF(" #%s @ %p]\n", Token::Name(op), static_cast<void*>(*code));
     }
 #endif
     BinaryOpIC ic(isolate);
     ic.patch(*code);
 
     // Activate inlined smi code.
     if (previous_overall == BinaryOpIC::UNINITIALIZED) {
       PatchInlinedSmiCode(ic.address(), ENABLE_INLINED_SMI_CHECK);
     }
@@ skipping 87 matching lines @@
 
 
 Handle<Type> CompareIC::StateToType(
     Isolate* isolate,
     CompareIC::State state,
     Handle<Map> map) {
   switch (state) {
     case CompareIC::UNINITIALIZED:
       return handle(Type::None(), isolate);
     case CompareIC::SMI:
-      return handle(Type::Integer31(), isolate);
+      return handle(Type::Smi(), isolate);
     case CompareIC::NUMBER:
       return handle(Type::Number(), isolate);
     case CompareIC::STRING:
       return handle(Type::String(), isolate);
     case CompareIC::INTERNALIZED_STRING:
       return handle(Type::InternalizedString(), isolate);
     case CompareIC::UNIQUE_NAME:
       return handle(Type::UniqueName(), isolate);
     case CompareIC::OBJECT:
       return handle(Type::Receiver(), isolate);
@@ skipping 273 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal