Use constant types to represent the fixed right arg of a MOD.

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 2311 matching lines @@
   // to include SSE2 as well as non-SSE2 versions in the snapshot. For code
   // generation we always want it to reflect the current state.
   op_ = static_cast<Token::Value>(
       FIRST_TOKEN + OpField::decode(extra_ic_state));
   mode_ = OverwriteModeField::decode(extra_ic_state);
   fixed_right_arg_ = Maybe<int>(
       HasFixedRightArgField::decode(extra_ic_state),
       1 << FixedRightArgValueField::decode(extra_ic_state));
   left_kind_ = LeftKindField::decode(extra_ic_state);
   if (fixed_right_arg_.has_value) {
-    right_kind_ = Smi::IsValid(fixed_right_arg_.value) ? SMI : INT32;
+    // We have only 4 bits to encode the log2 of the fixed right arg, so the
+    // max value is 2^(2^4), which is always a SMI.
+    ASSERT(Smi::IsValid(fixed_right_arg_.value));
+    right_kind_ = SMI;
   } else {
     right_kind_ = RightKindField::decode(extra_ic_state);
   }
   result_kind_ = ResultKindField::decode(extra_ic_state);
   ASSERT_LE(FIRST_TOKEN, op_);
   ASSERT_LE(op_, LAST_TOKEN);
 }
 
 
 ExtraICState BinaryOpIC::State::GetExtraICState() const {
@@ skipping 232 matching lines @@
   GENERATE(Token::MOD, SMI, 4, SMI, NO_OVERWRITE);
   GENERATE(Token::MOD, SMI, 4, SMI, OVERWRITE_LEFT);
   GENERATE(Token::MOD, SMI, 8, SMI, NO_OVERWRITE);
   GENERATE(Token::MOD, SMI, 16, SMI, OVERWRITE_LEFT);
   GENERATE(Token::MOD, SMI, 32, SMI, NO_OVERWRITE);
   GENERATE(Token::MOD, SMI, 2048, SMI, NO_OVERWRITE);
 #undef GENERATE
 }
 
 
+Handle<Type> BinaryOpIC::State::GetRightType(Isolate* isolate) const {
+  if (fixed_right_arg_.has_value) {
+    Handle<Smi> value = handle(Smi::FromInt(fixed_right_arg_.value), isolate);
+    Handle<Type> type = handle(Type::Constant(value, isolate), isolate);
+    ASSERT(type->Is(KindToType(right_kind_, isolate)));
+    return type;
+  }
+  return KindToType(right_kind_, isolate);
+}
+
+
 Handle<Type> BinaryOpIC::State::GetResultType(Isolate* isolate) const {
   Kind result_kind = result_kind_;
   if (HasSideEffects()) {
     result_kind = NONE;
   } else if (result_kind == GENERIC && op_ == Token::ADD) {
     return handle(Type::Union(handle(Type::Number(), isolate),
                               handle(Type::String(), isolate)), isolate);
   } else if (result_kind == NUMBER && op_ == Token::SHR) {
     return handle(Type::Unsigned32(), isolate);
   }
@@ skipping 548 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal