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