src/ic/ic-state.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/v8.h"
   6
   7 #include "src/ic/ic.h"
   8 #include "src/ic/ic-state.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13 // static
  14 void ICUtility::Clear(Isolate* isolate, Address address,
  15                       Address constant_pool) {
  16   IC::Clear(isolate, address, constant_pool);
  17 }
  18
  19
  20 CallICState::CallICState(ExtraICState extra_ic_state)
  21     : argc_(ArgcBits::decode(extra_ic_state)),
  22       call_type_(CallTypeBits::decode(extra_ic_state)) {}
  23
  24
  25 ExtraICState CallICState::GetExtraICState() const {
  26   ExtraICState extra_ic_state =
  27       ArgcBits::encode(argc_) | CallTypeBits::encode(call_type_);
  28   return extra_ic_state;
  29 }
  30
  31
  32 std::ostream& operator<<(std::ostream& os, const CallICState& s) {
  33   return os << "(args(" << s.arg_count() << "), "
  34             << (s.call_type() == CallICState::METHOD ? "METHOD" : "FUNCTION")
  35             << ", ";
  36 }
  37
  38
  39 // static
  40 STATIC_CONST_MEMBER_DEFINITION const int BinaryOpICState::FIRST_TOKEN;
  41
  42
  43 // static
  44 STATIC_CONST_MEMBER_DEFINITION const int BinaryOpICState::LAST_TOKEN;
  45
  46
  47 BinaryOpICState::BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state)
  48     : fixed_right_arg_(
  49           HasFixedRightArgField::decode(extra_ic_state)
  50               ? Just(1 << FixedRightArgValueField::decode(extra_ic_state))
  51               : Nothing<int>()),
  52       isolate_(isolate) {
  53   op_ =
  54       static_cast<Token::Value>(FIRST_TOKEN + OpField::decode(extra_ic_state));
  55   strong_ = StrongField::decode(extra_ic_state);
  56   left_kind_ = LeftKindField::decode(extra_ic_state);
  57   right_kind_ = fixed_right_arg_.IsJust()
  58                     ? (Smi::IsValid(fixed_right_arg_.FromJust()) ? SMI : INT32)
  59                     : RightKindField::decode(extra_ic_state);
  60   result_kind_ = ResultKindField::decode(extra_ic_state);
  61   DCHECK_LE(FIRST_TOKEN, op_);
  62   DCHECK_LE(op_, LAST_TOKEN);
  63 }
  64
  65
  66 ExtraICState BinaryOpICState::GetExtraICState() const {
  67   ExtraICState extra_ic_state =
  68       OpField::encode(op_ - FIRST_TOKEN) | LeftKindField::encode(left_kind_) |
  69       ResultKindField::encode(result_kind_) |
  70       StrongField::encode(strong_) |
  71       HasFixedRightArgField::encode(fixed_right_arg_.IsJust());
  72   if (fixed_right_arg_.IsJust()) {
  73     extra_ic_state = FixedRightArgValueField::update(
  74         extra_ic_state, WhichPowerOf2(fixed_right_arg_.FromJust()));
  75   } else {
  76     extra_ic_state = RightKindField::update(extra_ic_state, right_kind_);
  77   }
  78   return extra_ic_state;
  79 }
  80
  81
  82 // static
  83 void BinaryOpICState::GenerateAheadOfTime(
  84     Isolate* isolate, void (*Generate)(Isolate*, const BinaryOpICState&)) {
  85 // TODO(olivf) We should investigate why adding stubs to the snapshot is so
  86 // expensive at runtime. When solved we should be able to add most binops to
  87 // the snapshot instead of hand-picking them.
  88 // Generated list of commonly used stubs
  89 #define GENERATE(op, left_kind, right_kind, result_kind)      \
  90   do {                                                        \
  91     BinaryOpICState state(isolate, op, LanguageMode::SLOPPY); \
  92     state.left_kind_ = left_kind;                             \
  93     state.fixed_right_arg_ = Nothing<int>();                  \
  94     state.right_kind_ = right_kind;                           \
  95     state.result_kind_ = result_kind;                         \
  96     Generate(isolate, state);                                 \
  97   } while (false)
  98   GENERATE(Token::ADD, INT32, INT32, INT32);
  99   GENERATE(Token::ADD, INT32, INT32, NUMBER);
 100   GENERATE(Token::ADD, INT32, NUMBER, NUMBER);
 101   GENERATE(Token::ADD, INT32, SMI, INT32);
 102   GENERATE(Token::ADD, NUMBER, INT32, NUMBER);
 103   GENERATE(Token::ADD, NUMBER, NUMBER, NUMBER);
 104   GENERATE(Token::ADD, NUMBER, SMI, NUMBER);
 105   GENERATE(Token::ADD, SMI, INT32, INT32);
 106   GENERATE(Token::ADD, SMI, INT32, NUMBER);
 107   GENERATE(Token::ADD, SMI, NUMBER, NUMBER);
 108   GENERATE(Token::ADD, SMI, SMI, INT32);
 109   GENERATE(Token::ADD, SMI, SMI, SMI);
 110   GENERATE(Token::BIT_AND, INT32, INT32, INT32);
 111   GENERATE(Token::BIT_AND, INT32, INT32, SMI);
 112   GENERATE(Token::BIT_AND, INT32, SMI, INT32);
 113   GENERATE(Token::BIT_AND, INT32, SMI, SMI);
 114   GENERATE(Token::BIT_AND, NUMBER, INT32, INT32);
 115   GENERATE(Token::BIT_AND, NUMBER, SMI, SMI);
 116   GENERATE(Token::BIT_AND, SMI, INT32, INT32);
 117   GENERATE(Token::BIT_AND, SMI, INT32, SMI);
 118   GENERATE(Token::BIT_AND, SMI, NUMBER, SMI);
 119   GENERATE(Token::BIT_AND, SMI, SMI, SMI);
 120   GENERATE(Token::BIT_OR, INT32, INT32, INT32);
 121   GENERATE(Token::BIT_OR, INT32, INT32, SMI);
 122   GENERATE(Token::BIT_OR, INT32, SMI, INT32);
 123   GENERATE(Token::BIT_OR, INT32, SMI, SMI);
 124   GENERATE(Token::BIT_OR, NUMBER, SMI, INT32);
 125   GENERATE(Token::BIT_OR, NUMBER, SMI, SMI);
 126   GENERATE(Token::BIT_OR, SMI, INT32, INT32);
 127   GENERATE(Token::BIT_OR, SMI, INT32, SMI);
 128   GENERATE(Token::BIT_OR, SMI, SMI, SMI);
 129   GENERATE(Token::BIT_XOR, INT32, INT32, INT32);
 130   GENERATE(Token::BIT_XOR, INT32, INT32, SMI);
 131   GENERATE(Token::BIT_XOR, INT32, NUMBER, SMI);
 132   GENERATE(Token::BIT_XOR, INT32, SMI, INT32);
 133   GENERATE(Token::BIT_XOR, NUMBER, INT32, INT32);
 134   GENERATE(Token::BIT_XOR, NUMBER, SMI, INT32);
 135   GENERATE(Token::BIT_XOR, NUMBER, SMI, SMI);
 136   GENERATE(Token::BIT_XOR, SMI, INT32, INT32);
 137   GENERATE(Token::BIT_XOR, SMI, INT32, SMI);
 138   GENERATE(Token::BIT_XOR, SMI, SMI, SMI);
 139   GENERATE(Token::DIV, INT32, INT32, INT32);
 140   GENERATE(Token::DIV, INT32, INT32, NUMBER);
 141   GENERATE(Token::DIV, INT32, NUMBER, NUMBER);
 142   GENERATE(Token::DIV, INT32, SMI, INT32);
 143   GENERATE(Token::DIV, INT32, SMI, NUMBER);
 144   GENERATE(Token::DIV, NUMBER, INT32, NUMBER);
 145   GENERATE(Token::DIV, NUMBER, NUMBER, NUMBER);
 146   GENERATE(Token::DIV, NUMBER, SMI, NUMBER);
 147   GENERATE(Token::DIV, SMI, INT32, INT32);
 148   GENERATE(Token::DIV, SMI, INT32, NUMBER);
 149   GENERATE(Token::DIV, SMI, NUMBER, NUMBER);
 150   GENERATE(Token::DIV, SMI, SMI, NUMBER);
 151   GENERATE(Token::DIV, SMI, SMI, SMI);
 152   GENERATE(Token::MOD, NUMBER, SMI, NUMBER);
 153   GENERATE(Token::MOD, SMI, SMI, SMI);
 154   GENERATE(Token::MUL, INT32, INT32, INT32);
 155   GENERATE(Token::MUL, INT32, INT32, NUMBER);
 156   GENERATE(Token::MUL, INT32, NUMBER, NUMBER);
 157   GENERATE(Token::MUL, INT32, SMI, INT32);
 158   GENERATE(Token::MUL, INT32, SMI, NUMBER);
 159   GENERATE(Token::MUL, NUMBER, INT32, NUMBER);
 160   GENERATE(Token::MUL, NUMBER, NUMBER, NUMBER);
 161   GENERATE(Token::MUL, NUMBER, SMI, NUMBER);
 162   GENERATE(Token::MUL, SMI, INT32, INT32);
 163   GENERATE(Token::MUL, SMI, INT32, NUMBER);
 164   GENERATE(Token::MUL, SMI, NUMBER, NUMBER);
 165   GENERATE(Token::MUL, SMI, SMI, INT32);
 166   GENERATE(Token::MUL, SMI, SMI, NUMBER);
 167   GENERATE(Token::MUL, SMI, SMI, SMI);
 168   GENERATE(Token::SAR, INT32, SMI, INT32);
 169   GENERATE(Token::SAR, INT32, SMI, SMI);
 170   GENERATE(Token::SAR, NUMBER, SMI, SMI);
 171   GENERATE(Token::SAR, SMI, SMI, SMI);
 172   GENERATE(Token::SHL, INT32, SMI, INT32);
 173   GENERATE(Token::SHL, INT32, SMI, SMI);
 174   GENERATE(Token::SHL, NUMBER, SMI, SMI);
 175   GENERATE(Token::SHL, SMI, SMI, INT32);
 176   GENERATE(Token::SHL, SMI, SMI, SMI);
 177   GENERATE(Token::SHR, INT32, SMI, SMI);
 178   GENERATE(Token::SHR, NUMBER, SMI, INT32);
 179   GENERATE(Token::SHR, NUMBER, SMI, SMI);
 180   GENERATE(Token::SHR, SMI, SMI, SMI);
 181   GENERATE(Token::SUB, INT32, INT32, INT32);
 182   GENERATE(Token::SUB, INT32, NUMBER, NUMBER);
 183   GENERATE(Token::SUB, INT32, SMI, INT32);
 184   GENERATE(Token::SUB, NUMBER, INT32, NUMBER);
 185   GENERATE(Token::SUB, NUMBER, NUMBER, NUMBER);
 186   GENERATE(Token::SUB, NUMBER, SMI, NUMBER);
 187   GENERATE(Token::SUB, SMI, INT32, INT32);
 188   GENERATE(Token::SUB, SMI, NUMBER, NUMBER);
 189   GENERATE(Token::SUB, SMI, SMI, SMI);
 190 #undef GENERATE
 191 #define GENERATE(op, left_kind, fixed_right_arg_value, result_kind) \
 192   do {                                                              \
 193     BinaryOpICState state(isolate, op, LanguageMode::SLOPPY);       \
 194     state.left_kind_ = left_kind;                                   \
 195     state.fixed_right_arg_ = Just(fixed_right_arg_value);           \
 196     state.right_kind_ = SMI;                                        \
 197     state.result_kind_ = result_kind;                               \
 198     Generate(isolate, state);                                       \
 199   } while (false)
 200   GENERATE(Token::MOD, SMI, 2, SMI);
 201   GENERATE(Token::MOD, SMI, 4, SMI);
 202   GENERATE(Token::MOD, SMI, 8, SMI);
 203   GENERATE(Token::MOD, SMI, 16, SMI);
 204   GENERATE(Token::MOD, SMI, 32, SMI);
 205   GENERATE(Token::MOD, SMI, 2048, SMI);
 206 #undef GENERATE
 207 }
 208
 209
 210 Type* BinaryOpICState::GetResultType(Zone* zone) const {
 211   Kind result_kind = result_kind_;
 212   if (HasSideEffects()) {
 213     result_kind = NONE;
 214   } else if (result_kind == GENERIC && op_ == Token::ADD) {
 215     return Type::Union(Type::Number(zone), Type::String(zone), zone);
 216   } else if (result_kind == NUMBER && op_ == Token::SHR) {
 217     return Type::Unsigned32(zone);
 218   }
 219   DCHECK_NE(GENERIC, result_kind);
 220   return KindToType(result_kind, zone);
 221 }
 222
 223
 224 std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s) {
 225   os << "(" << Token::Name(s.op_);
 226   if (s.CouldCreateAllocationMementos()) os << "_CreateAllocationMementos";
 227   os << ":" << BinaryOpICState::KindToString(s.left_kind_) << "*";
 228   if (s.fixed_right_arg_.IsJust()) {
 229     os << s.fixed_right_arg_.FromJust();
 230   } else {
 231     os << BinaryOpICState::KindToString(s.right_kind_);
 232   }
 233   return os << "->" << BinaryOpICState::KindToString(s.result_kind_) << ")";
 234 }
 235
 236
 237 void BinaryOpICState::Update(Handle<Object> left, Handle<Object> right,
 238                              Handle<Object> result) {
 239   ExtraICState old_extra_ic_state = GetExtraICState();
 240
 241   left_kind_ = UpdateKind(left, left_kind_);
 242   right_kind_ = UpdateKind(right, right_kind_);
 243
 244   int32_t fixed_right_arg_value = 0;
 245   bool has_fixed_right_arg =
 246       op_ == Token::MOD && right->ToInt32(&fixed_right_arg_value) &&
 247       fixed_right_arg_value > 0 &&
 248       base::bits::IsPowerOfTwo32(fixed_right_arg_value) &&
 249       FixedRightArgValueField::is_valid(WhichPowerOf2(fixed_right_arg_value)) &&
 250       (left_kind_ == SMI || left_kind_ == INT32) &&
 251       (result_kind_ == NONE || !fixed_right_arg_.IsJust());
 252   fixed_right_arg_ =
 253       has_fixed_right_arg ? Just(fixed_right_arg_value) : Nothing<int32_t>();
 254   result_kind_ = UpdateKind(result, result_kind_);
 255
 256   if (!Token::IsTruncatingBinaryOp(op_)) {
 257     Kind input_kind = Max(left_kind_, right_kind_);
 258     if (result_kind_ < input_kind && input_kind <= NUMBER) {
 259       result_kind_ = input_kind;
 260     }
 261   }
 262
 263   // We don't want to distinguish INT32 and NUMBER for string add (because
 264   // NumberToString can't make use of this anyway).
 265   if (left_kind_ == STRING && right_kind_ == INT32) {
 266     DCHECK_EQ(STRING, result_kind_);
 267     DCHECK_EQ(Token::ADD, op_);
 268     right_kind_ = NUMBER;
 269   } else if (right_kind_ == STRING && left_kind_ == INT32) {
 270     DCHECK_EQ(STRING, result_kind_);
 271     DCHECK_EQ(Token::ADD, op_);
 272     left_kind_ = NUMBER;
 273   }
 274
 275   if (old_extra_ic_state == GetExtraICState()) {
 276     // Tagged operations can lead to non-truncating HChanges
 277     if (left->IsUndefined() || left->IsBoolean()) {
 278       left_kind_ = GENERIC;
 279     } else {
 280       DCHECK(right->IsUndefined() || right->IsBoolean());
 281       right_kind_ = GENERIC;
 282     }
 283   }
 284 }
 285
 286
 287 BinaryOpICState::Kind BinaryOpICState::UpdateKind(Handle<Object> object,
 288                                                   Kind kind) const {
 289   Kind new_kind = GENERIC;
 290   bool is_truncating = Token::IsTruncatingBinaryOp(op());
 291   if (object->IsBoolean() && is_truncating) {
 292     // Booleans will be automatically truncated by HChange.
 293     new_kind = INT32;
 294   } else if (object->IsUndefined()) {
 295     // Undefined will be automatically truncated by HChange.
 296     new_kind = is_truncating ? INT32 : NUMBER;
 297   } else if (object->IsSmi()) {
 298     new_kind = SMI;
 299   } else if (object->IsHeapNumber()) {
 300     double value = Handle<HeapNumber>::cast(object)->value();
 301     new_kind = IsInt32Double(value) ? INT32 : NUMBER;
 302   } else if (object->IsString() && op() == Token::ADD) {
 303     new_kind = STRING;
 304   }
 305   if (new_kind == INT32 && SmiValuesAre32Bits()) {
 306     new_kind = NUMBER;
 307   }
 308   if (kind != NONE && ((new_kind <= NUMBER && kind > NUMBER) ||
 309                        (new_kind > NUMBER && kind <= NUMBER))) {
 310     new_kind = GENERIC;
 311   }
 312   return Max(kind, new_kind);
 313 }
 314
 315
 316 // static
 317 const char* BinaryOpICState::KindToString(Kind kind) {
 318   switch (kind) {
 319     case NONE:
 320       return "None";
 321     case SMI:
 322       return "Smi";
 323     case INT32:
 324       return "Int32";
 325     case NUMBER:
 326       return "Number";
 327     case STRING:
 328       return "String";
 329     case GENERIC:
 330       return "Generic";
 331   }
 332   UNREACHABLE();
 333   return NULL;
 334 }
 335
 336
 337 // static
 338 Type* BinaryOpICState::KindToType(Kind kind, Zone* zone) {
 339   switch (kind) {
 340     case NONE:
 341       return Type::None(zone);
 342     case SMI:
 343       return Type::SignedSmall(zone);
 344     case INT32:
 345       return Type::Signed32(zone);
 346     case NUMBER:
 347       return Type::Number(zone);
 348     case STRING:
 349       return Type::String(zone);
 350     case GENERIC:
 351       return Type::Any(zone);
 352   }
 353   UNREACHABLE();
 354   return NULL;
 355 }
 356
 357
 358 const char* CompareICState::GetStateName(State state) {
 359   switch (state) {
 360     case UNINITIALIZED:
 361       return "UNINITIALIZED";
 362     case SMI:
 363       return "SMI";
 364     case NUMBER:
 365       return "NUMBER";
 366     case INTERNALIZED_STRING:
 367       return "INTERNALIZED_STRING";
 368     case STRING:
 369       return "STRING";
 370     case UNIQUE_NAME:
 371       return "UNIQUE_NAME";
 372     case OBJECT:
 373       return "OBJECT";
 374     case KNOWN_OBJECT:
 375       return "KNOWN_OBJECT";
 376     case GENERIC:
 377       return "GENERIC";
 378   }
 379   UNREACHABLE();
 380   return NULL;
 381 }
 382
 383
 384 Type* CompareICState::StateToType(Zone* zone, State state, Handle<Map> map) {
 385   switch (state) {
 386     case UNINITIALIZED:
 387       return Type::None(zone);
 388     case SMI:
 389       return Type::SignedSmall(zone);
 390     case NUMBER:
 391       return Type::Number(zone);
 392     case STRING:
 393       return Type::String(zone);
 394     case INTERNALIZED_STRING:
 395       return Type::InternalizedString(zone);
 396     case UNIQUE_NAME:
 397       return Type::UniqueName(zone);
 398     case OBJECT:
 399       return Type::Receiver(zone);
 400     case KNOWN_OBJECT:
 401       return map.is_null() ? Type::Receiver(zone) : Type::Class(map, zone);
 402     case GENERIC:
 403       return Type::Any(zone);
 404   }
 405   UNREACHABLE();
 406   return NULL;
 407 }
 408
 409
 410 CompareICState::State CompareICState::NewInputState(State old_state,
 411                                                     Handle<Object> value) {
 412   switch (old_state) {
 413     case UNINITIALIZED:
 414       if (value->IsSmi()) return SMI;
 415       if (value->IsHeapNumber()) return NUMBER;
 416       if (value->IsInternalizedString()) return INTERNALIZED_STRING;
 417       if (value->IsString()) return STRING;
 418       if (value->IsSymbol()) return UNIQUE_NAME;
 419       if (value->IsJSObject()) return OBJECT;
 420       break;
 421     case SMI:
 422       if (value->IsSmi()) return SMI;
 423       if (value->IsHeapNumber()) return NUMBER;
 424       break;
 425     case NUMBER:
 426       if (value->IsNumber()) return NUMBER;
 427       break;
 428     case INTERNALIZED_STRING:
 429       if (value->IsInternalizedString()) return INTERNALIZED_STRING;
 430       if (value->IsString()) return STRING;
 431       if (value->IsSymbol()) return UNIQUE_NAME;
 432       break;
 433     case STRING:
 434       if (value->IsString()) return STRING;
 435       break;
 436     case UNIQUE_NAME:
 437       if (value->IsUniqueName()) return UNIQUE_NAME;
 438       break;
 439     case OBJECT:
 440       if (value->IsJSObject()) return OBJECT;
 441       break;
 442     case GENERIC:
 443       break;
 444     case KNOWN_OBJECT:
 445       UNREACHABLE();
 446       break;
 447   }
 448   return GENERIC;
 449 }
 450
 451
 452 // static
 453 CompareICState::State CompareICState::TargetState(
 454     State old_state, State old_left, State old_right, Token::Value op,
 455     bool has_inlined_smi_code, Handle<Object> x, Handle<Object> y) {
 456   switch (old_state) {
 457     case UNINITIALIZED:
 458       if (x->IsSmi() && y->IsSmi()) return SMI;
 459       if (x->IsNumber() && y->IsNumber()) return NUMBER;
 460       if (Token::IsOrderedRelationalCompareOp(op)) {
 461         // Ordered comparisons treat undefined as NaN, so the
 462         // NUMBER stub will do the right thing.
 463         if ((x->IsNumber() && y->IsUndefined()) ||
 464             (y->IsNumber() && x->IsUndefined())) {
 465           return NUMBER;
 466         }
 467       }
 468       if (x->IsInternalizedString() && y->IsInternalizedString()) {
 469         // We compare internalized strings as plain ones if we need to determine
 470         // the order in a non-equality compare.
 471         return Token::IsEqualityOp(op) ? INTERNALIZED_STRING : STRING;
 472       }
 473       if (x->IsString() && y->IsString()) return STRING;
 474       if (!Token::IsEqualityOp(op)) return GENERIC;
 475       if (x->IsUniqueName() && y->IsUniqueName()) return UNIQUE_NAME;
 476       if (x->IsJSObject() && y->IsJSObject()) {
 477         if (Handle<JSObject>::cast(x)->map() ==
 478             Handle<JSObject>::cast(y)->map()) {
 479           return KNOWN_OBJECT;
 480         } else {
 481           return OBJECT;
 482         }
 483       }
 484       return GENERIC;
 485     case SMI:
 486       return x->IsNumber() && y->IsNumber() ? NUMBER : GENERIC;
 487     case INTERNALIZED_STRING:
 488       DCHECK(Token::IsEqualityOp(op));
 489       if (x->IsString() && y->IsString()) return STRING;
 490       if (x->IsUniqueName() && y->IsUniqueName()) return UNIQUE_NAME;
 491       return GENERIC;
 492     case NUMBER:
 493       // If the failure was due to one side changing from smi to heap number,
 494       // then keep the state (if other changed at the same time, we will get
 495       // a second miss and then go to generic).
 496       if (old_left == SMI && x->IsHeapNumber()) return NUMBER;
 497       if (old_right == SMI && y->IsHeapNumber()) return NUMBER;
 498       return GENERIC;
 499     case KNOWN_OBJECT:
 500       DCHECK(Token::IsEqualityOp(op));
 501       if (x->IsJSObject() && y->IsJSObject()) {
 502         return OBJECT;
 503       }
 504       return GENERIC;
 505     case STRING:
 506     case UNIQUE_NAME:
 507     case OBJECT:
 508     case GENERIC:
 509       return GENERIC;
 510   }
 511   UNREACHABLE();
 512   return GENERIC;  // Make the compiler happy.
 513 }
 514 }  // namespace internal
 515 }  // namespace v8