1 // Copyright 2012 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 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_ 6 #define V8_HYDROGEN_INSTRUCTIONS_H_ 7 8 #include "src/v8.h" 9 10 #include "src/allocation.h" 11 #include "src/base/bits.h" 12 #include "src/code-stubs.h" 13 #include "src/conversions.h" 14 #include "src/data-flow.h" 15 #include "src/deoptimizer.h" 16 #include "src/feedback-slots.h" 17 #include "src/hydrogen-types.h" 18 #include "src/small-pointer-list.h" 19 #include "src/unique.h" 20 #include "src/utils.h" 21 #include "src/zone.h" 22 23 namespace v8 { 24 namespace internal { 25 26 // Forward declarations. 27 struct ChangesOf; 28 class HBasicBlock; 29 class HDiv; 30 class HEnvironment; 31 class HInferRepresentationPhase; 32 class HInstruction; 33 class HLoopInformation; 34 class HStoreNamedField; 35 class HValue; 36 class LInstruction; 37 class LChunkBuilder; 38 class OStream; 39 40 #define HYDROGEN_ABSTRACT_INSTRUCTION_LIST(V) \ 41 V(ArithmeticBinaryOperation) \ 42 V(BinaryOperation) \ 43 V(BitwiseBinaryOperation) \ 44 V(ControlInstruction) \ 45 V(Instruction) 46 47 48 #define HYDROGEN_CONCRETE_INSTRUCTION_LIST(V) \ 49 V(AbnormalExit) \ 50 V(AccessArgumentsAt) \ 51 V(Add) \ 52 V(AllocateBlockContext) \ 53 V(Allocate) \ 54 V(ApplyArguments) \ 55 V(ArgumentsElements) \ 56 V(ArgumentsLength) \ 57 V(ArgumentsObject) \ 58 V(Bitwise) \ 59 V(BlockEntry) \ 60 V(BoundsCheck) \ 61 V(BoundsCheckBaseIndexInformation) \ 62 V(Branch) \ 63 V(CallWithDescriptor) \ 64 V(CallJSFunction) \ 65 V(CallFunction) \ 66 V(CallNew) \ 67 V(CallNewArray) \ 68 V(CallRuntime) \ 69 V(CallStub) \ 70 V(CapturedObject) \ 71 V(Change) \ 72 V(CheckHeapObject) \ 73 V(CheckInstanceType) \ 74 V(CheckMaps) \ 75 V(CheckMapValue) \ 76 V(CheckSmi) \ 77 V(CheckValue) \ 78 V(ClampToUint8) \ 79 V(ClassOfTestAndBranch) \ 80 V(CompareNumericAndBranch) \ 81 V(CompareHoleAndBranch) \ 82 V(CompareGeneric) \ 83 V(CompareMinusZeroAndBranch) \ 84 V(CompareObjectEqAndBranch) \ 85 V(CompareMap) \ 86 V(Constant) \ 87 V(ConstructDouble) \ 88 V(Context) \ 89 V(DateField) \ 90 V(DebugBreak) \ 91 V(DeclareGlobals) \ 92 V(Deoptimize) \ 93 V(Div) \ 94 V(DoubleBits) \ 95 V(DummyUse) \ 96 V(EnterInlined) \ 97 V(EnvironmentMarker) \ 98 V(ForceRepresentation) \ 99 V(ForInCacheArray) \ 100 V(ForInPrepareMap) \ 101 V(FunctionLiteral) \ 102 V(GetCachedArrayIndex) \ 103 V(Goto) \ 104 V(HasCachedArrayIndexAndBranch) \ 105 V(HasInstanceTypeAndBranch) \ 106 V(InnerAllocatedObject) \ 107 V(InstanceOf) \ 108 V(InstanceOfKnownGlobal) \ 109 V(InvokeFunction) \ 110 V(IsConstructCallAndBranch) \ 111 V(IsObjectAndBranch) \ 112 V(IsStringAndBranch) \ 113 V(IsSmiAndBranch) \ 114 V(IsUndetectableAndBranch) \ 115 V(LeaveInlined) \ 116 V(LoadContextSlot) \ 117 V(LoadFieldByIndex) \ 118 V(LoadFunctionPrototype) \ 119 V(LoadGlobalCell) \ 120 V(LoadGlobalGeneric) \ 121 V(LoadKeyed) \ 122 V(LoadKeyedGeneric) \ 123 V(LoadNamedField) \ 124 V(LoadNamedGeneric) \ 125 V(LoadRoot) \ 126 V(MapEnumLength) \ 127 V(MathFloorOfDiv) \ 128 V(MathMinMax) \ 129 V(Mod) \ 130 V(Mul) \ 131 V(OsrEntry) \ 132 V(Parameter) \ 133 V(Power) \ 134 V(PushArguments) \ 135 V(RegExpLiteral) \ 136 V(Return) \ 137 V(Ror) \ 138 V(Sar) \ 139 V(SeqStringGetChar) \ 140 V(SeqStringSetChar) \ 141 V(Shl) \ 142 V(Shr) \ 143 V(Simulate) \ 144 V(StackCheck) \ 145 V(StoreCodeEntry) \ 146 V(StoreContextSlot) \ 147 V(StoreFrameContext) \ 148 V(StoreGlobalCell) \ 149 V(StoreKeyed) \ 150 V(StoreKeyedGeneric) \ 151 V(StoreNamedField) \ 152 V(StoreNamedGeneric) \ 153 V(StringAdd) \ 154 V(StringCharCodeAt) \ 155 V(StringCharFromCode) \ 156 V(StringCompareAndBranch) \ 157 V(Sub) \ 158 V(TailCallThroughMegamorphicCache) \ 159 V(ThisFunction) \ 160 V(ToFastProperties) \ 161 V(TransitionElementsKind) \ 162 V(TrapAllocationMemento) \ 163 V(Typeof) \ 164 V(TypeofIsAndBranch) \ 165 V(UnaryMathOperation) \ 166 V(UnknownOSRValue) \ 167 V(UseConst) \ 168 V(WrapReceiver) 169 170 #define GVN_TRACKED_FLAG_LIST(V) \ 171 V(NewSpacePromotion) 172 173 #define GVN_UNTRACKED_FLAG_LIST(V) \ 174 V(ArrayElements) \ 175 V(ArrayLengths) \ 176 V(StringLengths) \ 177 V(BackingStoreFields) \ 178 V(Calls) \ 179 V(ContextSlots) \ 180 V(DoubleArrayElements) \ 181 V(DoubleFields) \ 182 V(ElementsKind) \ 183 V(ElementsPointer) \ 184 V(GlobalVars) \ 185 V(InobjectFields) \ 186 V(Maps) \ 187 V(OsrEntries) \ 188 V(ExternalMemory) \ 189 V(StringChars) \ 190 V(TypedArrayElements) 191 192 193 #define DECLARE_ABSTRACT_INSTRUCTION(type) \ 194 virtual bool Is##type() const FINAL OVERRIDE { return true; } \ 195 static H##type* cast(HValue* value) { \ 196 DCHECK(value->Is##type()); \ 197 return reinterpret_cast<H##type*>(value); \ 198 } 199 200 201 #define DECLARE_CONCRETE_INSTRUCTION(type) \ 202 virtual LInstruction* CompileToLithium( \ 203 LChunkBuilder* builder) FINAL OVERRIDE; \ 204 static H##type* cast(HValue* value) { \ 205 DCHECK(value->Is##type()); \ 206 return reinterpret_cast<H##type*>(value); \ 207 } \ 208 virtual Opcode opcode() const FINAL OVERRIDE { \ 209 return HValue::k##type; \ 210 } 211 212 213 enum PropertyAccessType { LOAD, STORE }; 214 215 216 class Range FINAL : public ZoneObject { 217 public: 218 Range() 219 : lower_(kMinInt), 220 upper_(kMaxInt), 221 next_(NULL), 222 can_be_minus_zero_(false) { } 223 224 Range(int32_t lower, int32_t upper) 225 : lower_(lower), 226 upper_(upper), 227 next_(NULL), 228 can_be_minus_zero_(false) { } 229 230 int32_t upper() const { return upper_; } 231 int32_t lower() const { return lower_; } 232 Range* next() const { return next_; } 233 Range* CopyClearLower(Zone* zone) const { 234 return new(zone) Range(kMinInt, upper_); 235 } 236 Range* CopyClearUpper(Zone* zone) const { 237 return new(zone) Range(lower_, kMaxInt); 238 } 239 Range* Copy(Zone* zone) const { 240 Range* result = new(zone) Range(lower_, upper_); 241 result->set_can_be_minus_zero(CanBeMinusZero()); 242 return result; 243 } 244 int32_t Mask() const; 245 void set_can_be_minus_zero(bool b) { can_be_minus_zero_ = b; } 246 bool CanBeMinusZero() const { return CanBeZero() && can_be_minus_zero_; } 247 bool CanBeZero() const { return upper_ >= 0 && lower_ <= 0; } 248 bool CanBeNegative() const { return lower_ < 0; } 249 bool CanBePositive() const { return upper_ > 0; } 250 bool Includes(int value) const { return lower_ <= value && upper_ >= value; } 251 bool IsMostGeneric() const { 252 return lower_ == kMinInt && upper_ == kMaxInt && CanBeMinusZero(); 253 } 254 bool IsInSmiRange() const { 255 return lower_ >= Smi::kMinValue && upper_ <= Smi::kMaxValue; 256 } 257 void ClampToSmi() { 258 lower_ = Max(lower_, Smi::kMinValue); 259 upper_ = Min(upper_, Smi::kMaxValue); 260 } 261 void KeepOrder(); 262 #ifdef DEBUG 263 void Verify() const; 264 #endif 265 266 void StackUpon(Range* other) { 267 Intersect(other); 268 next_ = other; 269 } 270 271 void Intersect(Range* other); 272 void Union(Range* other); 273 void CombinedMax(Range* other); 274 void CombinedMin(Range* other); 275 276 void AddConstant(int32_t value); 277 void Sar(int32_t value); 278 void Shl(int32_t value); 279 bool AddAndCheckOverflow(const Representation& r, Range* other); 280 bool SubAndCheckOverflow(const Representation& r, Range* other); 281 bool MulAndCheckOverflow(const Representation& r, Range* other); 282 283 private: 284 int32_t lower_; 285 int32_t upper_; 286 Range* next_; 287 bool can_be_minus_zero_; 288 }; 289 290 291 class HUseListNode: public ZoneObject { 292 public: 293 HUseListNode(HValue* value, int index, HUseListNode* tail) 294 : tail_(tail), value_(value), index_(index) { 295 } 296 297 HUseListNode* tail(); 298 HValue* value() const { return value_; } 299 int index() const { return index_; } 300 301 void set_tail(HUseListNode* list) { tail_ = list; } 302 303 #ifdef DEBUG 304 void Zap() { 305 tail_ = reinterpret_cast<HUseListNode*>(1); 306 value_ = NULL; 307 index_ = -1; 308 } 309 #endif 310 311 private: 312 HUseListNode* tail_; 313 HValue* value_; 314 int index_; 315 }; 316 317 318 // We reuse use list nodes behind the scenes as uses are added and deleted. 319 // This class is the safe way to iterate uses while deleting them. 320 class HUseIterator FINAL BASE_EMBEDDED { 321 public: 322 bool Done() { return current_ == NULL; } 323 void Advance(); 324 325 HValue* value() { 326 DCHECK(!Done()); 327 return value_; 328 } 329 330 int index() { 331 DCHECK(!Done()); 332 return index_; 333 } 334 335 private: 336 explicit HUseIterator(HUseListNode* head); 337 338 HUseListNode* current_; 339 HUseListNode* next_; 340 HValue* value_; 341 int index_; 342 343 friend class HValue; 344 }; 345 346 347 // All tracked flags should appear before untracked ones. 348 enum GVNFlag { 349 // Declare global value numbering flags. 350 #define DECLARE_FLAG(Type) k##Type, 351 GVN_TRACKED_FLAG_LIST(DECLARE_FLAG) 352 GVN_UNTRACKED_FLAG_LIST(DECLARE_FLAG) 353 #undef DECLARE_FLAG 354 #define COUNT_FLAG(Type) + 1 355 kNumberOfTrackedSideEffects = 0 GVN_TRACKED_FLAG_LIST(COUNT_FLAG), 356 kNumberOfUntrackedSideEffects = 0 GVN_UNTRACKED_FLAG_LIST(COUNT_FLAG), 357 #undef COUNT_FLAG 358 kNumberOfFlags = kNumberOfTrackedSideEffects + kNumberOfUntrackedSideEffects 359 }; 360 361 362 static inline GVNFlag GVNFlagFromInt(int i) { 363 DCHECK(i >= 0); 364 DCHECK(i < kNumberOfFlags); 365 return static_cast<GVNFlag>(i); 366 } 367 368 369 class DecompositionResult FINAL BASE_EMBEDDED { 370 public: 371 DecompositionResult() : base_(NULL), offset_(0), scale_(0) {} 372 373 HValue* base() { return base_; } 374 int offset() { return offset_; } 375 int scale() { return scale_; } 376 377 bool Apply(HValue* other_base, int other_offset, int other_scale = 0) { 378 if (base_ == NULL) { 379 base_ = other_base; 380 offset_ = other_offset; 381 scale_ = other_scale; 382 return true; 383 } else { 384 if (scale_ == 0) { 385 base_ = other_base; 386 offset_ += other_offset; 387 scale_ = other_scale; 388 return true; 389 } else { 390 return false; 391 } 392 } 393 } 394 395 void SwapValues(HValue** other_base, int* other_offset, int* other_scale) { 396 swap(&base_, other_base); 397 swap(&offset_, other_offset); 398 swap(&scale_, other_scale); 399 } 400 401 private: 402 template <class T> void swap(T* a, T* b) { 403 T c(*a); 404 *a = *b; 405 *b = c; 406 } 407 408 HValue* base_; 409 int offset_; 410 int scale_; 411 }; 412 413 414 typedef EnumSet<GVNFlag, int32_t> GVNFlagSet; 415 416 417 // This class encapsulates encoding and decoding of sources positions from 418 // which hydrogen values originated. 419 // When FLAG_track_hydrogen_positions is set this object encodes the 420 // identifier of the inlining and absolute offset from the start of the 421 // inlined function. 422 // When the flag is not set we simply track absolute offset from the 423 // script start. 424 class HSourcePosition { 425 public: 426 HSourcePosition(const HSourcePosition& other) : value_(other.value_) { } 427 428 static HSourcePosition Unknown() { 429 return HSourcePosition(RelocInfo::kNoPosition); 430 } 431 432 bool IsUnknown() const { return value_ == RelocInfo::kNoPosition; } 433 434 int position() const { return PositionField::decode(value_); } 435 void set_position(int position) { 436 if (FLAG_hydrogen_track_positions) { 437 value_ = static_cast<int>(PositionField::update(value_, position)); 438 } else { 439 value_ = position; 440 } 441 } 442 443 int inlining_id() const { return InliningIdField::decode(value_); } 444 void set_inlining_id(int inlining_id) { 445 if (FLAG_hydrogen_track_positions) { 446 value_ = static_cast<int>(InliningIdField::update(value_, inlining_id)); 447 } 448 } 449 450 int raw() const { return value_; } 451 452 private: 453 typedef BitField<int, 0, 9> InliningIdField; 454 455 // Offset from the start of the inlined function. 456 typedef BitField<int, 9, 23> PositionField; 457 458 explicit HSourcePosition(int value) : value_(value) { } 459 460 friend class HPositionInfo; 461 friend class LCodeGenBase; 462 463 // If FLAG_hydrogen_track_positions is set contains bitfields InliningIdField 464 // and PositionField. 465 // Otherwise contains absolute offset from the script start. 466 int value_; 467 }; 468 469 470 OStream& operator<<(OStream& os, const HSourcePosition& p); 471 472 473 class HValue : public ZoneObject { 474 public: 475 static const int kNoNumber = -1; 476 477 enum Flag { 478 kFlexibleRepresentation, 479 kCannotBeTagged, 480 // Participate in Global Value Numbering, i.e. elimination of 481 // unnecessary recomputations. If an instruction sets this flag, it must 482 // implement DataEquals(), which will be used to determine if other 483 // occurrences of the instruction are indeed the same. 484 kUseGVN, 485 // Track instructions that are dominating side effects. If an instruction 486 // sets this flag, it must implement HandleSideEffectDominator() and should 487 // indicate which side effects to track by setting GVN flags. 488 kTrackSideEffectDominators, 489 kCanOverflow, 490 kBailoutOnMinusZero, 491 kCanBeDivByZero, 492 kLeftCanBeMinInt, 493 kLeftCanBeNegative, 494 kLeftCanBePositive, 495 kAllowUndefinedAsNaN, 496 kIsArguments, 497 kTruncatingToInt32, 498 kAllUsesTruncatingToInt32, 499 kTruncatingToSmi, 500 kAllUsesTruncatingToSmi, 501 // Set after an instruction is killed. 502 kIsDead, 503 // Instructions that are allowed to produce full range unsigned integer 504 // values are marked with kUint32 flag. If arithmetic shift or a load from 505 // EXTERNAL_UINT32_ELEMENTS array is not marked with this flag 506 // it will deoptimize if result does not fit into signed integer range. 507 // HGraph::ComputeSafeUint32Operations is responsible for setting this 508 // flag. 509 kUint32, 510 kHasNoObservableSideEffects, 511 // Indicates an instruction shouldn't be replaced by optimization, this flag 512 // is useful to set in cases where recomputing a value is cheaper than 513 // extending the value's live range and spilling it. 514 kCantBeReplaced, 515 // Indicates the instruction is live during dead code elimination. 516 kIsLive, 517 518 // HEnvironmentMarkers are deleted before dead code 519 // elimination takes place, so they can repurpose the kIsLive flag: 520 kEndsLiveRange = kIsLive, 521 522 // TODO(everyone): Don't forget to update this! 523 kLastFlag = kIsLive 524 }; 525 526 STATIC_ASSERT(kLastFlag < kBitsPerInt); 527 528 static HValue* cast(HValue* value) { return value; } 529 530 enum Opcode { 531 // Declare a unique enum value for each hydrogen instruction. 532 #define DECLARE_OPCODE(type) k##type, 533 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE) 534 kPhi 535 #undef DECLARE_OPCODE 536 }; 537 virtual Opcode opcode() const = 0; 538 539 // Declare a non-virtual predicates for each concrete HInstruction or HValue. 540 #define DECLARE_PREDICATE(type) \ 541 bool Is##type() const { return opcode() == k##type; } 542 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE) 543 #undef DECLARE_PREDICATE 544 bool IsPhi() const { return opcode() == kPhi; } 545 546 // Declare virtual predicates for abstract HInstruction or HValue 547 #define DECLARE_PREDICATE(type) \ 548 virtual bool Is##type() const { return false; } 549 HYDROGEN_ABSTRACT_INSTRUCTION_LIST(DECLARE_PREDICATE) 550 #undef DECLARE_PREDICATE 551 552 bool IsBitwiseBinaryShift() { 553 return IsShl() || IsShr() || IsSar(); 554 } 555 556 explicit HValue(HType type = HType::Tagged()) 557 : block_(NULL), 558 id_(kNoNumber), 559 type_(type), 560 use_list_(NULL), 561 range_(NULL), 562 #ifdef DEBUG 563 range_poisoned_(false), 564 #endif 565 flags_(0) {} 566 virtual ~HValue() {} 567 568 virtual HSourcePosition position() const { 569 return HSourcePosition::Unknown(); 570 } 571 virtual HSourcePosition operand_position(int index) const { 572 return position(); 573 } 574 575 HBasicBlock* block() const { return block_; } 576 void SetBlock(HBasicBlock* block); 577 578 // Note: Never call this method for an unlinked value. 579 Isolate* isolate() const; 580 581 int id() const { return id_; } 582 void set_id(int id) { id_ = id; } 583 584 HUseIterator uses() const { return HUseIterator(use_list_); } 585 586 virtual bool EmitAtUses() { return false; } 587 588 Representation representation() const { return representation_; } 589 void ChangeRepresentation(Representation r) { 590 DCHECK(CheckFlag(kFlexibleRepresentation)); 591 DCHECK(!CheckFlag(kCannotBeTagged) || !r.IsTagged()); 592 RepresentationChanged(r); 593 representation_ = r; 594 if (r.IsTagged()) { 595 // Tagged is the bottom of the lattice, don't go any further. 596 ClearFlag(kFlexibleRepresentation); 597 } 598 } 599 virtual void AssumeRepresentation(Representation r); 600 601 virtual Representation KnownOptimalRepresentation() { 602 Representation r = representation(); 603 if (r.IsTagged()) { 604 HType t = type(); 605 if (t.IsSmi()) return Representation::Smi(); 606 if (t.IsHeapNumber()) return Representation::Double(); 607 if (t.IsHeapObject()) return r; 608 return Representation::None(); 609 } 610 return r; 611 } 612 613 HType type() const { return type_; } 614 void set_type(HType new_type) { 615 DCHECK(new_type.IsSubtypeOf(type_)); 616 type_ = new_type; 617 } 618 619 // There are HInstructions that do not really change a value, they 620 // only add pieces of information to it (like bounds checks, map checks, 621 // smi checks...). 622 // We call these instructions "informative definitions", or "iDef". 623 // One of the iDef operands is special because it is the value that is 624 // "transferred" to the output, we call it the "redefined operand". 625 // If an HValue is an iDef it must override RedefinedOperandIndex() so that 626 // it does not return kNoRedefinedOperand; 627 static const int kNoRedefinedOperand = -1; 628 virtual int RedefinedOperandIndex() { return kNoRedefinedOperand; } 629 bool IsInformativeDefinition() { 630 return RedefinedOperandIndex() != kNoRedefinedOperand; 631 } 632 HValue* RedefinedOperand() { 633 int index = RedefinedOperandIndex(); 634 return index == kNoRedefinedOperand ? NULL : OperandAt(index); 635 } 636 637 bool CanReplaceWithDummyUses(); 638 639 virtual int argument_delta() const { return 0; } 640 641 // A purely informative definition is an idef that will not emit code and 642 // should therefore be removed from the graph in the RestoreActualValues 643 // phase (so that live ranges will be shorter). 644 virtual bool IsPurelyInformativeDefinition() { return false; } 645 646 // This method must always return the original HValue SSA definition, 647 // regardless of any chain of iDefs of this value. 648 HValue* ActualValue() { 649 HValue* value = this; 650 int index; 651 while ((index = value->RedefinedOperandIndex()) != kNoRedefinedOperand) { 652 value = value->OperandAt(index); 653 } 654 return value; 655 } 656 657 bool IsInteger32Constant(); 658 int32_t GetInteger32Constant(); 659 bool EqualsInteger32Constant(int32_t value); 660 661 bool IsDefinedAfter(HBasicBlock* other) const; 662 663 // Operands. 664 virtual int OperandCount() const = 0; 665 virtual HValue* OperandAt(int index) const = 0; 666 void SetOperandAt(int index, HValue* value); 667 668 void DeleteAndReplaceWith(HValue* other); 669 void ReplaceAllUsesWith(HValue* other); 670 bool HasNoUses() const { return use_list_ == NULL; } 671 bool HasOneUse() const { 672 return use_list_ != NULL && use_list_->tail() == NULL; 673 } 674 bool HasMultipleUses() const { 675 return use_list_ != NULL && use_list_->tail() != NULL; 676 } 677 int UseCount() const; 678 679 // Mark this HValue as dead and to be removed from other HValues' use lists. 680 void Kill(); 681 682 int flags() const { return flags_; } 683 void SetFlag(Flag f) { flags_ |= (1 << f); } 684 void ClearFlag(Flag f) { flags_ &= ~(1 << f); } 685 bool CheckFlag(Flag f) const { return (flags_ & (1 << f)) != 0; } 686 void CopyFlag(Flag f, HValue* other) { 687 if (other->CheckFlag(f)) SetFlag(f); 688 } 689 690 // Returns true if the flag specified is set for all uses, false otherwise. 691 bool CheckUsesForFlag(Flag f) const; 692 // Same as before and the first one without the flag is returned in value. 693 bool CheckUsesForFlag(Flag f, HValue** value) const; 694 // Returns true if the flag specified is set for all uses, and this set 695 // of uses is non-empty. 696 bool HasAtLeastOneUseWithFlagAndNoneWithout(Flag f) const; 697 698 GVNFlagSet ChangesFlags() const { return changes_flags_; } 699 GVNFlagSet DependsOnFlags() const { return depends_on_flags_; } 700 void SetChangesFlag(GVNFlag f) { changes_flags_.Add(f); } 701 void SetDependsOnFlag(GVNFlag f) { depends_on_flags_.Add(f); } 702 void ClearChangesFlag(GVNFlag f) { changes_flags_.Remove(f); } 703 void ClearDependsOnFlag(GVNFlag f) { depends_on_flags_.Remove(f); } 704 bool CheckChangesFlag(GVNFlag f) const { 705 return changes_flags_.Contains(f); 706 } 707 bool CheckDependsOnFlag(GVNFlag f) const { 708 return depends_on_flags_.Contains(f); 709 } 710 void SetAllSideEffects() { changes_flags_.Add(AllSideEffectsFlagSet()); } 711 void ClearAllSideEffects() { 712 changes_flags_.Remove(AllSideEffectsFlagSet()); 713 } 714 bool HasSideEffects() const { 715 return changes_flags_.ContainsAnyOf(AllSideEffectsFlagSet()); 716 } 717 bool HasObservableSideEffects() const { 718 return !CheckFlag(kHasNoObservableSideEffects) && 719 changes_flags_.ContainsAnyOf(AllObservableSideEffectsFlagSet()); 720 } 721 722 GVNFlagSet SideEffectFlags() const { 723 GVNFlagSet result = ChangesFlags(); 724 result.Intersect(AllSideEffectsFlagSet()); 725 return result; 726 } 727 728 GVNFlagSet ObservableChangesFlags() const { 729 GVNFlagSet result = ChangesFlags(); 730 result.Intersect(AllObservableSideEffectsFlagSet()); 731 return result; 732 } 733 734 Range* range() const { 735 DCHECK(!range_poisoned_); 736 return range_; 737 } 738 bool HasRange() const { 739 DCHECK(!range_poisoned_); 740 return range_ != NULL; 741 } 742 #ifdef DEBUG 743 void PoisonRange() { range_poisoned_ = true; } 744 #endif 745 void AddNewRange(Range* r, Zone* zone); 746 void RemoveLastAddedRange(); 747 void ComputeInitialRange(Zone* zone); 748 749 // Escape analysis helpers. 750 virtual bool HasEscapingOperandAt(int index) { return true; } 751 virtual bool HasOutOfBoundsAccess(int size) { return false; } 752 753 // Representation helpers. 754 virtual Representation observed_input_representation(int index) { 755 return Representation::None(); 756 } 757 virtual Representation RequiredInputRepresentation(int index) = 0; 758 virtual void InferRepresentation(HInferRepresentationPhase* h_infer); 759 760 // This gives the instruction an opportunity to replace itself with an 761 // instruction that does the same in some better way. To replace an 762 // instruction with a new one, first add the new instruction to the graph, 763 // then return it. Return NULL to have the instruction deleted. 764 virtual HValue* Canonicalize() { return this; } 765 766 bool Equals(HValue* other); 767 virtual intptr_t Hashcode(); 768 769 // Compute unique ids upfront that is safe wrt GC and concurrent compilation. 770 virtual void FinalizeUniqueness() { } 771 772 // Printing support. 773 virtual OStream& PrintTo(OStream& os) const = 0; // NOLINT 774 775 const char* Mnemonic() const; 776 777 // Type information helpers. 778 bool HasMonomorphicJSObjectType(); 779 780 // TODO(mstarzinger): For now instructions can override this function to 781 // specify statically known types, once HType can convey more information 782 // it should be based on the HType. 783 virtual Handle<Map> GetMonomorphicJSObjectMap() { return Handle<Map>(); } 784 785 // Updated the inferred type of this instruction and returns true if 786 // it has changed. 787 bool UpdateInferredType(); 788 789 virtual HType CalculateInferredType(); 790 791 // This function must be overridden for instructions which have the 792 // kTrackSideEffectDominators flag set, to track instructions that are 793 // dominating side effects. 794 // It returns true if it removed an instruction which had side effects. 795 virtual bool HandleSideEffectDominator(GVNFlag side_effect, 796 HValue* dominator) { 797 UNREACHABLE(); 798 return false; 799 } 800 801 // Check if this instruction has some reason that prevents elimination. 802 bool CannotBeEliminated() const { 803 return HasObservableSideEffects() || !IsDeletable(); 804 } 805 806 #ifdef DEBUG 807 virtual void Verify() = 0; 808 #endif 809 810 virtual bool TryDecompose(DecompositionResult* decomposition) { 811 if (RedefinedOperand() != NULL) { 812 return RedefinedOperand()->TryDecompose(decomposition); 813 } else { 814 return false; 815 } 816 } 817 818 // Returns true conservatively if the program might be able to observe a 819 // ToString() operation on this value. 820 bool ToStringCanBeObserved() const { 821 return ToStringOrToNumberCanBeObserved(); 822 } 823 824 // Returns true conservatively if the program might be able to observe a 825 // ToNumber() operation on this value. 826 bool ToNumberCanBeObserved() const { 827 return ToStringOrToNumberCanBeObserved(); 828 } 829 830 MinusZeroMode GetMinusZeroMode() { 831 return CheckFlag(kBailoutOnMinusZero) 832 ? FAIL_ON_MINUS_ZERO : TREAT_MINUS_ZERO_AS_ZERO; 833 } 834 835 protected: 836 // This function must be overridden for instructions with flag kUseGVN, to 837 // compare the non-Operand parts of the instruction. 838 virtual bool DataEquals(HValue* other) { 839 UNREACHABLE(); 840 return false; 841 } 842 843 bool ToStringOrToNumberCanBeObserved() const { 844 if (type().IsTaggedPrimitive()) return false; 845 if (type().IsJSObject()) return true; 846 return !representation().IsSmiOrInteger32() && !representation().IsDouble(); 847 } 848 849 virtual Representation RepresentationFromInputs() { 850 return representation(); 851 } 852 virtual Representation RepresentationFromUses(); 853 Representation RepresentationFromUseRequirements(); 854 bool HasNonSmiUse(); 855 virtual void UpdateRepresentation(Representation new_rep, 856 HInferRepresentationPhase* h_infer, 857 const char* reason); 858 void AddDependantsToWorklist(HInferRepresentationPhase* h_infer); 859 860 virtual void RepresentationChanged(Representation to) { } 861 862 virtual Range* InferRange(Zone* zone); 863 virtual void DeleteFromGraph() = 0; 864 virtual void InternalSetOperandAt(int index, HValue* value) = 0; 865 void clear_block() { 866 DCHECK(block_ != NULL); 867 block_ = NULL; 868 } 869 870 void set_representation(Representation r) { 871 DCHECK(representation_.IsNone() && !r.IsNone()); 872 representation_ = r; 873 } 874 875 static GVNFlagSet AllFlagSet() { 876 GVNFlagSet result; 877 #define ADD_FLAG(Type) result.Add(k##Type); 878 GVN_TRACKED_FLAG_LIST(ADD_FLAG) 879 GVN_UNTRACKED_FLAG_LIST(ADD_FLAG) 880 #undef ADD_FLAG 881 return result; 882 } 883 884 // A flag mask to mark an instruction as having arbitrary side effects. 885 static GVNFlagSet AllSideEffectsFlagSet() { 886 GVNFlagSet result = AllFlagSet(); 887 result.Remove(kOsrEntries); 888 return result; 889 } 890 friend OStream& operator<<(OStream& os, const ChangesOf& v); 891 892 // A flag mask of all side effects that can make observable changes in 893 // an executing program (i.e. are not safe to repeat, move or remove); 894 static GVNFlagSet AllObservableSideEffectsFlagSet() { 895 GVNFlagSet result = AllFlagSet(); 896 result.Remove(kNewSpacePromotion); 897 result.Remove(kElementsKind); 898 result.Remove(kElementsPointer); 899 result.Remove(kMaps); 900 return result; 901 } 902 903 // Remove the matching use from the use list if present. Returns the 904 // removed list node or NULL. 905 HUseListNode* RemoveUse(HValue* value, int index); 906 907 void RegisterUse(int index, HValue* new_value); 908 909 HBasicBlock* block_; 910 911 // The id of this instruction in the hydrogen graph, assigned when first 912 // added to the graph. Reflects creation order. 913 int id_; 914 915 Representation representation_; 916 HType type_; 917 HUseListNode* use_list_; 918 Range* range_; 919 #ifdef DEBUG 920 bool range_poisoned_; 921 #endif 922 int flags_; 923 GVNFlagSet changes_flags_; 924 GVNFlagSet depends_on_flags_; 925 926 private: 927 virtual bool IsDeletable() const { return false; } 928 929 DISALLOW_COPY_AND_ASSIGN(HValue); 930 }; 931 932 // Support for printing various aspects of an HValue. 933 struct NameOf { 934 explicit NameOf(const HValue* const v) : value(v) {} 935 const HValue* value; 936 }; 937 938 939 struct TypeOf { 940 explicit TypeOf(const HValue* const v) : value(v) {} 941 const HValue* value; 942 }; 943 944 945 struct ChangesOf { 946 explicit ChangesOf(const HValue* const v) : value(v) {} 947 const HValue* value; 948 }; 949 950 951 OStream& operator<<(OStream& os, const HValue& v); 952 OStream& operator<<(OStream& os, const NameOf& v); 953 OStream& operator<<(OStream& os, const TypeOf& v); 954 OStream& operator<<(OStream& os, const ChangesOf& v); 955 956 957 #define DECLARE_INSTRUCTION_FACTORY_P0(I) \ 958 static I* New(Zone* zone, HValue* context) { \ 959 return new(zone) I(); \ 960 } 961 962 #define DECLARE_INSTRUCTION_FACTORY_P1(I, P1) \ 963 static I* New(Zone* zone, HValue* context, P1 p1) { \ 964 return new(zone) I(p1); \ 965 } 966 967 #define DECLARE_INSTRUCTION_FACTORY_P2(I, P1, P2) \ 968 static I* New(Zone* zone, HValue* context, P1 p1, P2 p2) { \ 969 return new(zone) I(p1, p2); \ 970 } 971 972 #define DECLARE_INSTRUCTION_FACTORY_P3(I, P1, P2, P3) \ 973 static I* New(Zone* zone, HValue* context, P1 p1, P2 p2, P3 p3) { \ 974 return new(zone) I(p1, p2, p3); \ 975 } 976 977 #define DECLARE_INSTRUCTION_FACTORY_P4(I, P1, P2, P3, P4) \ 978 static I* New(Zone* zone, \ 979 HValue* context, \ 980 P1 p1, \ 981 P2 p2, \ 982 P3 p3, \ 983 P4 p4) { \ 984 return new(zone) I(p1, p2, p3, p4); \ 985 } 986 987 #define DECLARE_INSTRUCTION_FACTORY_P5(I, P1, P2, P3, P4, P5) \ 988 static I* New(Zone* zone, \ 989 HValue* context, \ 990 P1 p1, \ 991 P2 p2, \ 992 P3 p3, \ 993 P4 p4, \ 994 P5 p5) { \ 995 return new(zone) I(p1, p2, p3, p4, p5); \ 996 } 997 998 #define DECLARE_INSTRUCTION_FACTORY_P6(I, P1, P2, P3, P4, P5, P6) \ 999 static I* New(Zone* zone, \ 1000 HValue* context, \ 1001 P1 p1, \ 1002 P2 p2, \ 1003 P3 p3, \ 1004 P4 p4, \ 1005 P5 p5, \ 1006 P6 p6) { \ 1007 return new(zone) I(p1, p2, p3, p4, p5, p6); \ 1008 } 1009 1010 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P0(I) \ 1011 static I* New(Zone* zone, HValue* context) { \ 1012 return new(zone) I(context); \ 1013 } 1014 1015 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(I, P1) \ 1016 static I* New(Zone* zone, HValue* context, P1 p1) { \ 1017 return new(zone) I(context, p1); \ 1018 } 1019 1020 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(I, P1, P2) \ 1021 static I* New(Zone* zone, HValue* context, P1 p1, P2 p2) { \ 1022 return new(zone) I(context, p1, p2); \ 1023 } 1024 1025 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(I, P1, P2, P3) \ 1026 static I* New(Zone* zone, HValue* context, P1 p1, P2 p2, P3 p3) { \ 1027 return new(zone) I(context, p1, p2, p3); \ 1028 } 1029 1030 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(I, P1, P2, P3, P4) \ 1031 static I* New(Zone* zone, \ 1032 HValue* context, \ 1033 P1 p1, \ 1034 P2 p2, \ 1035 P3 p3, \ 1036 P4 p4) { \ 1037 return new(zone) I(context, p1, p2, p3, p4); \ 1038 } 1039 1040 #define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(I, P1, P2, P3, P4, P5) \ 1041 static I* New(Zone* zone, \ 1042 HValue* context, \ 1043 P1 p1, \ 1044 P2 p2, \ 1045 P3 p3, \ 1046 P4 p4, \ 1047 P5 p5) { \ 1048 return new(zone) I(context, p1, p2, p3, p4, p5); \ 1049 } 1050 1051 1052 // A helper class to represent per-operand position information attached to 1053 // the HInstruction in the compact form. Uses tagging to distinguish between 1054 // case when only instruction's position is available and case when operands' 1055 // positions are also available. 1056 // In the first case it contains intruction's position as a tagged value. 1057 // In the second case it points to an array which contains instruction's 1058 // position and operands' positions. 1059 class HPositionInfo { 1060 public: 1061 explicit HPositionInfo(int pos) : data_(TagPosition(pos)) { } 1062 1063 HSourcePosition position() const { 1064 if (has_operand_positions()) { 1065 return operand_positions()[kInstructionPosIndex]; 1066 } 1067 return HSourcePosition(static_cast<int>(UntagPosition(data_))); 1068 } 1069 1070 void set_position(HSourcePosition pos) { 1071 if (has_operand_positions()) { 1072 operand_positions()[kInstructionPosIndex] = pos; 1073 } else { 1074 data_ = TagPosition(pos.raw()); 1075 } 1076 } 1077 1078 void ensure_storage_for_operand_positions(Zone* zone, int operand_count) { 1079 if (has_operand_positions()) { 1080 return; 1081 } 1082 1083 const int length = kFirstOperandPosIndex + operand_count; 1084 HSourcePosition* positions = 1085 zone->NewArray<HSourcePosition>(length); 1086 for (int i = 0; i < length; i++) { 1087 positions[i] = HSourcePosition::Unknown(); 1088 } 1089 1090 const HSourcePosition pos = position(); 1091 data_ = reinterpret_cast<intptr_t>(positions); 1092 set_position(pos); 1093 1094 DCHECK(has_operand_positions()); 1095 } 1096 1097 HSourcePosition operand_position(int idx) const { 1098 if (!has_operand_positions()) { 1099 return position(); 1100 } 1101 return *operand_position_slot(idx); 1102 } 1103 1104 void set_operand_position(int idx, HSourcePosition pos) { 1105 *operand_position_slot(idx) = pos; 1106 } 1107 1108 private: 1109 static const intptr_t kInstructionPosIndex = 0; 1110 static const intptr_t kFirstOperandPosIndex = 1; 1111 1112 HSourcePosition* operand_position_slot(int idx) const { 1113 DCHECK(has_operand_positions()); 1114 return &(operand_positions()[kFirstOperandPosIndex + idx]); 1115 } 1116 1117 bool has_operand_positions() const { 1118 return !IsTaggedPosition(data_); 1119 } 1120 1121 HSourcePosition* operand_positions() const { 1122 DCHECK(has_operand_positions()); 1123 return reinterpret_cast<HSourcePosition*>(data_); 1124 } 1125 1126 static const intptr_t kPositionTag = 1; 1127 static const intptr_t kPositionShift = 1; 1128 static bool IsTaggedPosition(intptr_t val) { 1129 return (val & kPositionTag) != 0; 1130 } 1131 static intptr_t UntagPosition(intptr_t val) { 1132 DCHECK(IsTaggedPosition(val)); 1133 return val >> kPositionShift; 1134 } 1135 static intptr_t TagPosition(intptr_t val) { 1136 const intptr_t result = (val << kPositionShift) | kPositionTag; 1137 DCHECK(UntagPosition(result) == val); 1138 return result; 1139 } 1140 1141 intptr_t data_; 1142 }; 1143 1144 1145 class HInstruction : public HValue { 1146 public: 1147 HInstruction* next() const { return next_; } 1148 HInstruction* previous() const { return previous_; } 1149 1150 virtual OStream& PrintTo(OStream& os) const OVERRIDE; // NOLINT 1151 virtual OStream& PrintDataTo(OStream& os) const; // NOLINT 1152 1153 bool IsLinked() const { return block() != NULL; } 1154 void Unlink(); 1155 1156 void InsertBefore(HInstruction* next); 1157 1158 template<class T> T* Prepend(T* instr) { 1159 instr->InsertBefore(this); 1160 return instr; 1161 } 1162 1163 void InsertAfter(HInstruction* previous); 1164 1165 template<class T> T* Append(T* instr) { 1166 instr->InsertAfter(this); 1167 return instr; 1168 } 1169 1170 // The position is a write-once variable. 1171 virtual HSourcePosition position() const OVERRIDE { 1172 return HSourcePosition(position_.position()); 1173 } 1174 bool has_position() const { 1175 return !position().IsUnknown(); 1176 } 1177 void set_position(HSourcePosition position) { 1178 DCHECK(!has_position()); 1179 DCHECK(!position.IsUnknown()); 1180 position_.set_position(position); 1181 } 1182 1183 virtual HSourcePosition operand_position(int index) const OVERRIDE { 1184 const HSourcePosition pos = position_.operand_position(index); 1185 return pos.IsUnknown() ? position() : pos; 1186 } 1187 void set_operand_position(Zone* zone, int index, HSourcePosition pos) { 1188 DCHECK(0 <= index && index < OperandCount()); 1189 position_.ensure_storage_for_operand_positions(zone, OperandCount()); 1190 position_.set_operand_position(index, pos); 1191 } 1192 1193 bool Dominates(HInstruction* other); 1194 bool CanTruncateToSmi() const { return CheckFlag(kTruncatingToSmi); } 1195 bool CanTruncateToInt32() const { return CheckFlag(kTruncatingToInt32); } 1196 1197 virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0; 1198 1199 #ifdef DEBUG 1200 virtual void Verify() OVERRIDE; 1201 #endif 1202 1203 bool CanDeoptimize(); 1204 1205 virtual bool HasStackCheck() { return false; } 1206 1207 DECLARE_ABSTRACT_INSTRUCTION(Instruction) 1208 1209 protected: 1210 explicit HInstruction(HType type = HType::Tagged()) 1211 : HValue(type), 1212 next_(NULL), 1213 previous_(NULL), 1214 position_(RelocInfo::kNoPosition) { 1215 SetDependsOnFlag(kOsrEntries); 1216 } 1217 1218 virtual void DeleteFromGraph() OVERRIDE { Unlink(); } 1219 1220 private: 1221 void InitializeAsFirst(HBasicBlock* block) { 1222 DCHECK(!IsLinked()); 1223 SetBlock(block); 1224 } 1225 1226 HInstruction* next_; 1227 HInstruction* previous_; 1228 HPositionInfo position_; 1229 1230 friend class HBasicBlock; 1231 }; 1232 1233 1234 template<int V> 1235 class HTemplateInstruction : public HInstruction { 1236 public: 1237 virtual int OperandCount() const FINAL OVERRIDE { return V; } 1238 virtual HValue* OperandAt(int i) const FINAL OVERRIDE { 1239 return inputs_[i]; 1240 } 1241 1242 protected: 1243 explicit HTemplateInstruction(HType type = HType::Tagged()) 1244 : HInstruction(type) {} 1245 1246 virtual void InternalSetOperandAt(int i, HValue* value) FINAL OVERRIDE { 1247 inputs_[i] = value; 1248 } 1249 1250 private: 1251 EmbeddedContainer<HValue*, V> inputs_; 1252 }; 1253 1254 1255 class HControlInstruction : public HInstruction { 1256 public: 1257 virtual HBasicBlock* SuccessorAt(int i) const = 0; 1258 virtual int SuccessorCount() const = 0; 1259 virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0; 1260 1261 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1262 1263 virtual bool KnownSuccessorBlock(HBasicBlock** block) { 1264 *block = NULL; 1265 return false; 1266 } 1267 1268 HBasicBlock* FirstSuccessor() { 1269 return SuccessorCount() > 0 ? SuccessorAt(0) : NULL; 1270 } 1271 HBasicBlock* SecondSuccessor() { 1272 return SuccessorCount() > 1 ? SuccessorAt(1) : NULL; 1273 } 1274 1275 void Not() { 1276 HBasicBlock* swap = SuccessorAt(0); 1277 SetSuccessorAt(0, SuccessorAt(1)); 1278 SetSuccessorAt(1, swap); 1279 } 1280 1281 DECLARE_ABSTRACT_INSTRUCTION(ControlInstruction) 1282 }; 1283 1284 1285 class HSuccessorIterator FINAL BASE_EMBEDDED { 1286 public: 1287 explicit HSuccessorIterator(const HControlInstruction* instr) 1288 : instr_(instr), current_(0) {} 1289 1290 bool Done() { return current_ >= instr_->SuccessorCount(); } 1291 HBasicBlock* Current() { return instr_->SuccessorAt(current_); } 1292 void Advance() { current_++; } 1293 1294 private: 1295 const HControlInstruction* instr_; 1296 int current_; 1297 }; 1298 1299 1300 template<int S, int V> 1301 class HTemplateControlInstruction : public HControlInstruction { 1302 public: 1303 int SuccessorCount() const OVERRIDE { return S; } 1304 HBasicBlock* SuccessorAt(int i) const OVERRIDE { return successors_[i]; } 1305 void SetSuccessorAt(int i, HBasicBlock* block) OVERRIDE { 1306 successors_[i] = block; 1307 } 1308 1309 int OperandCount() const OVERRIDE { return V; } 1310 HValue* OperandAt(int i) const OVERRIDE { return inputs_[i]; } 1311 1312 1313 protected: 1314 void InternalSetOperandAt(int i, HValue* value) OVERRIDE { 1315 inputs_[i] = value; 1316 } 1317 1318 private: 1319 EmbeddedContainer<HBasicBlock*, S> successors_; 1320 EmbeddedContainer<HValue*, V> inputs_; 1321 }; 1322 1323 1324 class HBlockEntry FINAL : public HTemplateInstruction<0> { 1325 public: 1326 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1327 return Representation::None(); 1328 } 1329 1330 DECLARE_CONCRETE_INSTRUCTION(BlockEntry) 1331 }; 1332 1333 1334 class HDummyUse FINAL : public HTemplateInstruction<1> { 1335 public: 1336 explicit HDummyUse(HValue* value) 1337 : HTemplateInstruction<1>(HType::Smi()) { 1338 SetOperandAt(0, value); 1339 // Pretend to be a Smi so that the HChange instructions inserted 1340 // before any use generate as little code as possible. 1341 set_representation(Representation::Tagged()); 1342 } 1343 1344 HValue* value() const { return OperandAt(0); } 1345 1346 virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; } 1347 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1348 return Representation::None(); 1349 } 1350 1351 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1352 1353 DECLARE_CONCRETE_INSTRUCTION(DummyUse); 1354 }; 1355 1356 1357 // Inserts an int3/stop break instruction for debugging purposes. 1358 class HDebugBreak FINAL : public HTemplateInstruction<0> { 1359 public: 1360 DECLARE_INSTRUCTION_FACTORY_P0(HDebugBreak); 1361 1362 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1363 return Representation::None(); 1364 } 1365 1366 DECLARE_CONCRETE_INSTRUCTION(DebugBreak) 1367 }; 1368 1369 1370 class HGoto FINAL : public HTemplateControlInstruction<1, 0> { 1371 public: 1372 explicit HGoto(HBasicBlock* target) { 1373 SetSuccessorAt(0, target); 1374 } 1375 1376 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE { 1377 *block = FirstSuccessor(); 1378 return true; 1379 } 1380 1381 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1382 return Representation::None(); 1383 } 1384 1385 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1386 1387 DECLARE_CONCRETE_INSTRUCTION(Goto) 1388 }; 1389 1390 1391 class HDeoptimize FINAL : public HTemplateControlInstruction<1, 0> { 1392 public: 1393 static HDeoptimize* New(Zone* zone, 1394 HValue* context, 1395 const char* reason, 1396 Deoptimizer::BailoutType type, 1397 HBasicBlock* unreachable_continuation) { 1398 return new(zone) HDeoptimize(reason, type, unreachable_continuation); 1399 } 1400 1401 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE { 1402 *block = NULL; 1403 return true; 1404 } 1405 1406 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1407 return Representation::None(); 1408 } 1409 1410 const char* reason() const { return reason_; } 1411 Deoptimizer::BailoutType type() { return type_; } 1412 1413 DECLARE_CONCRETE_INSTRUCTION(Deoptimize) 1414 1415 private: 1416 explicit HDeoptimize(const char* reason, 1417 Deoptimizer::BailoutType type, 1418 HBasicBlock* unreachable_continuation) 1419 : reason_(reason), type_(type) { 1420 SetSuccessorAt(0, unreachable_continuation); 1421 } 1422 1423 const char* reason_; 1424 Deoptimizer::BailoutType type_; 1425 }; 1426 1427 1428 class HUnaryControlInstruction : public HTemplateControlInstruction<2, 1> { 1429 public: 1430 HUnaryControlInstruction(HValue* value, 1431 HBasicBlock* true_target, 1432 HBasicBlock* false_target) { 1433 SetOperandAt(0, value); 1434 SetSuccessorAt(0, true_target); 1435 SetSuccessorAt(1, false_target); 1436 } 1437 1438 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1439 1440 HValue* value() const { return OperandAt(0); } 1441 }; 1442 1443 1444 class HBranch FINAL : public HUnaryControlInstruction { 1445 public: 1446 DECLARE_INSTRUCTION_FACTORY_P1(HBranch, HValue*); 1447 DECLARE_INSTRUCTION_FACTORY_P2(HBranch, HValue*, 1448 ToBooleanStub::Types); 1449 DECLARE_INSTRUCTION_FACTORY_P4(HBranch, HValue*, 1450 ToBooleanStub::Types, 1451 HBasicBlock*, HBasicBlock*); 1452 1453 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1454 return Representation::None(); 1455 } 1456 virtual Representation observed_input_representation(int index) OVERRIDE; 1457 1458 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 1459 1460 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1461 1462 ToBooleanStub::Types expected_input_types() const { 1463 return expected_input_types_; 1464 } 1465 1466 DECLARE_CONCRETE_INSTRUCTION(Branch) 1467 1468 private: 1469 HBranch(HValue* value, 1470 ToBooleanStub::Types expected_input_types = ToBooleanStub::Types(), 1471 HBasicBlock* true_target = NULL, 1472 HBasicBlock* false_target = NULL) 1473 : HUnaryControlInstruction(value, true_target, false_target), 1474 expected_input_types_(expected_input_types) { 1475 SetFlag(kAllowUndefinedAsNaN); 1476 } 1477 1478 ToBooleanStub::Types expected_input_types_; 1479 }; 1480 1481 1482 class HCompareMap FINAL : public HUnaryControlInstruction { 1483 public: 1484 DECLARE_INSTRUCTION_FACTORY_P2(HCompareMap, HValue*, Handle<Map>); 1485 DECLARE_INSTRUCTION_FACTORY_P4(HCompareMap, HValue*, Handle<Map>, 1486 HBasicBlock*, HBasicBlock*); 1487 1488 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE { 1489 if (known_successor_index() != kNoKnownSuccessorIndex) { 1490 *block = SuccessorAt(known_successor_index()); 1491 return true; 1492 } 1493 *block = NULL; 1494 return false; 1495 } 1496 1497 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1498 1499 static const int kNoKnownSuccessorIndex = -1; 1500 int known_successor_index() const { return known_successor_index_; } 1501 void set_known_successor_index(int known_successor_index) { 1502 known_successor_index_ = known_successor_index; 1503 } 1504 1505 Unique<Map> map() const { return map_; } 1506 bool map_is_stable() const { return map_is_stable_; } 1507 1508 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1509 return Representation::Tagged(); 1510 } 1511 1512 DECLARE_CONCRETE_INSTRUCTION(CompareMap) 1513 1514 protected: 1515 virtual int RedefinedOperandIndex() { return 0; } 1516 1517 private: 1518 HCompareMap(HValue* value, 1519 Handle<Map> map, 1520 HBasicBlock* true_target = NULL, 1521 HBasicBlock* false_target = NULL) 1522 : HUnaryControlInstruction(value, true_target, false_target), 1523 known_successor_index_(kNoKnownSuccessorIndex), 1524 map_is_stable_(map->is_stable()), 1525 map_(Unique<Map>::CreateImmovable(map)) { 1526 set_representation(Representation::Tagged()); 1527 } 1528 1529 int known_successor_index_ : 31; 1530 bool map_is_stable_ : 1; 1531 Unique<Map> map_; 1532 }; 1533 1534 1535 class HContext FINAL : public HTemplateInstruction<0> { 1536 public: 1537 static HContext* New(Zone* zone) { 1538 return new(zone) HContext(); 1539 } 1540 1541 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1542 return Representation::None(); 1543 } 1544 1545 DECLARE_CONCRETE_INSTRUCTION(Context) 1546 1547 protected: 1548 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 1549 1550 private: 1551 HContext() { 1552 set_representation(Representation::Tagged()); 1553 SetFlag(kUseGVN); 1554 } 1555 1556 virtual bool IsDeletable() const OVERRIDE { return true; } 1557 }; 1558 1559 1560 class HReturn FINAL : public HTemplateControlInstruction<0, 3> { 1561 public: 1562 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HReturn, HValue*, HValue*); 1563 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HReturn, HValue*); 1564 1565 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1566 // TODO(titzer): require an Int32 input for faster returns. 1567 if (index == 2) return Representation::Smi(); 1568 return Representation::Tagged(); 1569 } 1570 1571 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1572 1573 HValue* value() const { return OperandAt(0); } 1574 HValue* context() const { return OperandAt(1); } 1575 HValue* parameter_count() const { return OperandAt(2); } 1576 1577 DECLARE_CONCRETE_INSTRUCTION(Return) 1578 1579 private: 1580 HReturn(HValue* context, HValue* value, HValue* parameter_count = 0) { 1581 SetOperandAt(0, value); 1582 SetOperandAt(1, context); 1583 SetOperandAt(2, parameter_count); 1584 } 1585 }; 1586 1587 1588 class HAbnormalExit FINAL : public HTemplateControlInstruction<0, 0> { 1589 public: 1590 DECLARE_INSTRUCTION_FACTORY_P0(HAbnormalExit); 1591 1592 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1593 return Representation::None(); 1594 } 1595 1596 DECLARE_CONCRETE_INSTRUCTION(AbnormalExit) 1597 private: 1598 HAbnormalExit() {} 1599 }; 1600 1601 1602 class HUnaryOperation : public HTemplateInstruction<1> { 1603 public: 1604 explicit HUnaryOperation(HValue* value, HType type = HType::Tagged()) 1605 : HTemplateInstruction<1>(type) { 1606 SetOperandAt(0, value); 1607 } 1608 1609 static HUnaryOperation* cast(HValue* value) { 1610 return reinterpret_cast<HUnaryOperation*>(value); 1611 } 1612 1613 HValue* value() const { return OperandAt(0); } 1614 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1615 }; 1616 1617 1618 class HUseConst FINAL : public HUnaryOperation { 1619 public: 1620 DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*); 1621 1622 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1623 return Representation::None(); 1624 } 1625 1626 DECLARE_CONCRETE_INSTRUCTION(UseConst) 1627 1628 private: 1629 explicit HUseConst(HValue* old_value) : HUnaryOperation(old_value) { } 1630 }; 1631 1632 1633 class HForceRepresentation FINAL : public HTemplateInstruction<1> { 1634 public: 1635 static HInstruction* New(Zone* zone, HValue* context, HValue* value, 1636 Representation required_representation); 1637 1638 HValue* value() const { return OperandAt(0); } 1639 1640 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1641 return representation(); // Same as the output representation. 1642 } 1643 1644 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1645 1646 DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation) 1647 1648 private: 1649 HForceRepresentation(HValue* value, Representation required_representation) { 1650 SetOperandAt(0, value); 1651 set_representation(required_representation); 1652 } 1653 }; 1654 1655 1656 class HChange FINAL : public HUnaryOperation { 1657 public: 1658 HChange(HValue* value, 1659 Representation to, 1660 bool is_truncating_to_smi, 1661 bool is_truncating_to_int32) 1662 : HUnaryOperation(value) { 1663 DCHECK(!value->representation().IsNone()); 1664 DCHECK(!to.IsNone()); 1665 DCHECK(!value->representation().Equals(to)); 1666 set_representation(to); 1667 SetFlag(kUseGVN); 1668 SetFlag(kCanOverflow); 1669 if (is_truncating_to_smi && to.IsSmi()) { 1670 SetFlag(kTruncatingToSmi); 1671 SetFlag(kTruncatingToInt32); 1672 } 1673 if (is_truncating_to_int32) SetFlag(kTruncatingToInt32); 1674 if (value->representation().IsSmi() || value->type().IsSmi()) { 1675 set_type(HType::Smi()); 1676 } else { 1677 set_type(HType::TaggedNumber()); 1678 if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion); 1679 } 1680 } 1681 1682 bool can_convert_undefined_to_nan() { 1683 return CheckUsesForFlag(kAllowUndefinedAsNaN); 1684 } 1685 1686 virtual HType CalculateInferredType() OVERRIDE; 1687 virtual HValue* Canonicalize() OVERRIDE; 1688 1689 Representation from() const { return value()->representation(); } 1690 Representation to() const { return representation(); } 1691 bool deoptimize_on_minus_zero() const { 1692 return CheckFlag(kBailoutOnMinusZero); 1693 } 1694 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1695 return from(); 1696 } 1697 1698 virtual Range* InferRange(Zone* zone) OVERRIDE; 1699 1700 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1701 1702 DECLARE_CONCRETE_INSTRUCTION(Change) 1703 1704 protected: 1705 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 1706 1707 private: 1708 virtual bool IsDeletable() const OVERRIDE { 1709 return !from().IsTagged() || value()->type().IsSmi(); 1710 } 1711 }; 1712 1713 1714 class HClampToUint8 FINAL : public HUnaryOperation { 1715 public: 1716 DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*); 1717 1718 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1719 return Representation::None(); 1720 } 1721 1722 DECLARE_CONCRETE_INSTRUCTION(ClampToUint8) 1723 1724 protected: 1725 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 1726 1727 private: 1728 explicit HClampToUint8(HValue* value) 1729 : HUnaryOperation(value) { 1730 set_representation(Representation::Integer32()); 1731 SetFlag(kAllowUndefinedAsNaN); 1732 SetFlag(kUseGVN); 1733 } 1734 1735 virtual bool IsDeletable() const OVERRIDE { return true; } 1736 }; 1737 1738 1739 class HDoubleBits FINAL : public HUnaryOperation { 1740 public: 1741 enum Bits { HIGH, LOW }; 1742 DECLARE_INSTRUCTION_FACTORY_P2(HDoubleBits, HValue*, Bits); 1743 1744 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1745 return Representation::Double(); 1746 } 1747 1748 DECLARE_CONCRETE_INSTRUCTION(DoubleBits) 1749 1750 Bits bits() { return bits_; } 1751 1752 protected: 1753 virtual bool DataEquals(HValue* other) OVERRIDE { 1754 return other->IsDoubleBits() && HDoubleBits::cast(other)->bits() == bits(); 1755 } 1756 1757 private: 1758 HDoubleBits(HValue* value, Bits bits) 1759 : HUnaryOperation(value), bits_(bits) { 1760 set_representation(Representation::Integer32()); 1761 SetFlag(kUseGVN); 1762 } 1763 1764 virtual bool IsDeletable() const OVERRIDE { return true; } 1765 1766 Bits bits_; 1767 }; 1768 1769 1770 class HConstructDouble FINAL : public HTemplateInstruction<2> { 1771 public: 1772 DECLARE_INSTRUCTION_FACTORY_P2(HConstructDouble, HValue*, HValue*); 1773 1774 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1775 return Representation::Integer32(); 1776 } 1777 1778 DECLARE_CONCRETE_INSTRUCTION(ConstructDouble) 1779 1780 HValue* hi() { return OperandAt(0); } 1781 HValue* lo() { return OperandAt(1); } 1782 1783 protected: 1784 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 1785 1786 private: 1787 explicit HConstructDouble(HValue* hi, HValue* lo) { 1788 set_representation(Representation::Double()); 1789 SetFlag(kUseGVN); 1790 SetOperandAt(0, hi); 1791 SetOperandAt(1, lo); 1792 } 1793 1794 virtual bool IsDeletable() const OVERRIDE { return true; } 1795 }; 1796 1797 1798 enum RemovableSimulate { 1799 REMOVABLE_SIMULATE, 1800 FIXED_SIMULATE 1801 }; 1802 1803 1804 class HSimulate FINAL : public HInstruction { 1805 public: 1806 HSimulate(BailoutId ast_id, 1807 int pop_count, 1808 Zone* zone, 1809 RemovableSimulate removable) 1810 : ast_id_(ast_id), 1811 pop_count_(pop_count), 1812 values_(2, zone), 1813 assigned_indexes_(2, zone), 1814 zone_(zone), 1815 removable_(removable), 1816 done_with_replay_(false) {} 1817 ~HSimulate() {} 1818 1819 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1820 1821 bool HasAstId() const { return !ast_id_.IsNone(); } 1822 BailoutId ast_id() const { return ast_id_; } 1823 void set_ast_id(BailoutId id) { 1824 DCHECK(!HasAstId()); 1825 ast_id_ = id; 1826 } 1827 1828 int pop_count() const { return pop_count_; } 1829 const ZoneList<HValue*>* values() const { return &values_; } 1830 int GetAssignedIndexAt(int index) const { 1831 DCHECK(HasAssignedIndexAt(index)); 1832 return assigned_indexes_[index]; 1833 } 1834 bool HasAssignedIndexAt(int index) const { 1835 return assigned_indexes_[index] != kNoIndex; 1836 } 1837 void AddAssignedValue(int index, HValue* value) { 1838 AddValue(index, value); 1839 } 1840 void AddPushedValue(HValue* value) { 1841 AddValue(kNoIndex, value); 1842 } 1843 int ToOperandIndex(int environment_index) { 1844 for (int i = 0; i < assigned_indexes_.length(); ++i) { 1845 if (assigned_indexes_[i] == environment_index) return i; 1846 } 1847 return -1; 1848 } 1849 virtual int OperandCount() const OVERRIDE { return values_.length(); } 1850 virtual HValue* OperandAt(int index) const OVERRIDE { 1851 return values_[index]; 1852 } 1853 1854 virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; } 1855 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1856 return Representation::None(); 1857 } 1858 1859 void MergeWith(ZoneList<HSimulate*>* list); 1860 bool is_candidate_for_removal() { return removable_ == REMOVABLE_SIMULATE; } 1861 1862 // Replay effects of this instruction on the given environment. 1863 void ReplayEnvironment(HEnvironment* env); 1864 1865 DECLARE_CONCRETE_INSTRUCTION(Simulate) 1866 1867 #ifdef DEBUG 1868 virtual void Verify() OVERRIDE; 1869 void set_closure(Handle<JSFunction> closure) { closure_ = closure; } 1870 Handle<JSFunction> closure() const { return closure_; } 1871 #endif 1872 1873 protected: 1874 virtual void InternalSetOperandAt(int index, HValue* value) OVERRIDE { 1875 values_[index] = value; 1876 } 1877 1878 private: 1879 static const int kNoIndex = -1; 1880 void AddValue(int index, HValue* value) { 1881 assigned_indexes_.Add(index, zone_); 1882 // Resize the list of pushed values. 1883 values_.Add(NULL, zone_); 1884 // Set the operand through the base method in HValue to make sure that the 1885 // use lists are correctly updated. 1886 SetOperandAt(values_.length() - 1, value); 1887 } 1888 bool HasValueForIndex(int index) { 1889 for (int i = 0; i < assigned_indexes_.length(); ++i) { 1890 if (assigned_indexes_[i] == index) return true; 1891 } 1892 return false; 1893 } 1894 BailoutId ast_id_; 1895 int pop_count_; 1896 ZoneList<HValue*> values_; 1897 ZoneList<int> assigned_indexes_; 1898 Zone* zone_; 1899 RemovableSimulate removable_ : 2; 1900 bool done_with_replay_ : 1; 1901 1902 #ifdef DEBUG 1903 Handle<JSFunction> closure_; 1904 #endif 1905 }; 1906 1907 1908 class HEnvironmentMarker FINAL : public HTemplateInstruction<1> { 1909 public: 1910 enum Kind { BIND, LOOKUP }; 1911 1912 DECLARE_INSTRUCTION_FACTORY_P2(HEnvironmentMarker, Kind, int); 1913 1914 Kind kind() const { return kind_; } 1915 int index() const { return index_; } 1916 HSimulate* next_simulate() { return next_simulate_; } 1917 void set_next_simulate(HSimulate* simulate) { 1918 next_simulate_ = simulate; 1919 } 1920 1921 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1922 return Representation::None(); 1923 } 1924 1925 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 1926 1927 #ifdef DEBUG 1928 void set_closure(Handle<JSFunction> closure) { 1929 DCHECK(closure_.is_null()); 1930 DCHECK(!closure.is_null()); 1931 closure_ = closure; 1932 } 1933 Handle<JSFunction> closure() const { return closure_; } 1934 #endif 1935 1936 DECLARE_CONCRETE_INSTRUCTION(EnvironmentMarker); 1937 1938 private: 1939 HEnvironmentMarker(Kind kind, int index) 1940 : kind_(kind), index_(index), next_simulate_(NULL) { } 1941 1942 Kind kind_; 1943 int index_; 1944 HSimulate* next_simulate_; 1945 1946 #ifdef DEBUG 1947 Handle<JSFunction> closure_; 1948 #endif 1949 }; 1950 1951 1952 class HStackCheck FINAL : public HTemplateInstruction<1> { 1953 public: 1954 enum Type { 1955 kFunctionEntry, 1956 kBackwardsBranch 1957 }; 1958 1959 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HStackCheck, Type); 1960 1961 HValue* context() { return OperandAt(0); } 1962 1963 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 1964 return Representation::Tagged(); 1965 } 1966 1967 void Eliminate() { 1968 // The stack check eliminator might try to eliminate the same stack 1969 // check instruction multiple times. 1970 if (IsLinked()) { 1971 DeleteAndReplaceWith(NULL); 1972 } 1973 } 1974 1975 bool is_function_entry() { return type_ == kFunctionEntry; } 1976 bool is_backwards_branch() { return type_ == kBackwardsBranch; } 1977 1978 DECLARE_CONCRETE_INSTRUCTION(StackCheck) 1979 1980 private: 1981 HStackCheck(HValue* context, Type type) : type_(type) { 1982 SetOperandAt(0, context); 1983 SetChangesFlag(kNewSpacePromotion); 1984 } 1985 1986 Type type_; 1987 }; 1988 1989 1990 enum InliningKind { 1991 NORMAL_RETURN, // Drop the function from the environment on return. 1992 CONSTRUCT_CALL_RETURN, // Either use allocated receiver or return value. 1993 GETTER_CALL_RETURN, // Returning from a getter, need to restore context. 1994 SETTER_CALL_RETURN // Use the RHS of the assignment as the return value. 1995 }; 1996 1997 1998 class HArgumentsObject; 1999 class HConstant; 2000 2001 2002 class HEnterInlined FINAL : public HTemplateInstruction<0> { 2003 public: 2004 static HEnterInlined* New(Zone* zone, HValue* context, BailoutId return_id, 2005 Handle<JSFunction> closure, 2006 HConstant* closure_context, int arguments_count, 2007 FunctionLiteral* function, 2008 InliningKind inlining_kind, Variable* arguments_var, 2009 HArgumentsObject* arguments_object) { 2010 return new (zone) HEnterInlined(return_id, closure, closure_context, 2011 arguments_count, function, inlining_kind, 2012 arguments_var, arguments_object, zone); 2013 } 2014 2015 void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone); 2016 ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; } 2017 2018 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2019 2020 Handle<JSFunction> closure() const { return closure_; } 2021 HConstant* closure_context() const { return closure_context_; } 2022 int arguments_count() const { return arguments_count_; } 2023 bool arguments_pushed() const { return arguments_pushed_; } 2024 void set_arguments_pushed() { arguments_pushed_ = true; } 2025 FunctionLiteral* function() const { return function_; } 2026 InliningKind inlining_kind() const { return inlining_kind_; } 2027 BailoutId ReturnId() const { return return_id_; } 2028 2029 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2030 return Representation::None(); 2031 } 2032 2033 Variable* arguments_var() { return arguments_var_; } 2034 HArgumentsObject* arguments_object() { return arguments_object_; } 2035 2036 DECLARE_CONCRETE_INSTRUCTION(EnterInlined) 2037 2038 private: 2039 HEnterInlined(BailoutId return_id, Handle<JSFunction> closure, 2040 HConstant* closure_context, int arguments_count, 2041 FunctionLiteral* function, InliningKind inlining_kind, 2042 Variable* arguments_var, HArgumentsObject* arguments_object, 2043 Zone* zone) 2044 : return_id_(return_id), 2045 closure_(closure), 2046 closure_context_(closure_context), 2047 arguments_count_(arguments_count), 2048 arguments_pushed_(false), 2049 function_(function), 2050 inlining_kind_(inlining_kind), 2051 arguments_var_(arguments_var), 2052 arguments_object_(arguments_object), 2053 return_targets_(2, zone) {} 2054 2055 BailoutId return_id_; 2056 Handle<JSFunction> closure_; 2057 HConstant* closure_context_; 2058 int arguments_count_; 2059 bool arguments_pushed_; 2060 FunctionLiteral* function_; 2061 InliningKind inlining_kind_; 2062 Variable* arguments_var_; 2063 HArgumentsObject* arguments_object_; 2064 ZoneList<HBasicBlock*> return_targets_; 2065 }; 2066 2067 2068 class HLeaveInlined FINAL : public HTemplateInstruction<0> { 2069 public: 2070 HLeaveInlined(HEnterInlined* entry, 2071 int drop_count) 2072 : entry_(entry), 2073 drop_count_(drop_count) { } 2074 2075 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2076 return Representation::None(); 2077 } 2078 2079 virtual int argument_delta() const OVERRIDE { 2080 return entry_->arguments_pushed() ? -drop_count_ : 0; 2081 } 2082 2083 DECLARE_CONCRETE_INSTRUCTION(LeaveInlined) 2084 2085 private: 2086 HEnterInlined* entry_; 2087 int drop_count_; 2088 }; 2089 2090 2091 class HPushArguments FINAL : public HInstruction { 2092 public: 2093 static HPushArguments* New(Zone* zone, HValue* context) { 2094 return new(zone) HPushArguments(zone); 2095 } 2096 static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1) { 2097 HPushArguments* instr = new(zone) HPushArguments(zone); 2098 instr->AddInput(arg1); 2099 return instr; 2100 } 2101 static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1, 2102 HValue* arg2) { 2103 HPushArguments* instr = new(zone) HPushArguments(zone); 2104 instr->AddInput(arg1); 2105 instr->AddInput(arg2); 2106 return instr; 2107 } 2108 static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1, 2109 HValue* arg2, HValue* arg3) { 2110 HPushArguments* instr = new(zone) HPushArguments(zone); 2111 instr->AddInput(arg1); 2112 instr->AddInput(arg2); 2113 instr->AddInput(arg3); 2114 return instr; 2115 } 2116 static HPushArguments* New(Zone* zone, HValue* context, HValue* arg1, 2117 HValue* arg2, HValue* arg3, HValue* arg4) { 2118 HPushArguments* instr = new(zone) HPushArguments(zone); 2119 instr->AddInput(arg1); 2120 instr->AddInput(arg2); 2121 instr->AddInput(arg3); 2122 instr->AddInput(arg4); 2123 return instr; 2124 } 2125 2126 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2127 return Representation::Tagged(); 2128 } 2129 2130 virtual int argument_delta() const OVERRIDE { return inputs_.length(); } 2131 HValue* argument(int i) { return OperandAt(i); } 2132 2133 virtual int OperandCount() const FINAL OVERRIDE { 2134 return inputs_.length(); 2135 } 2136 virtual HValue* OperandAt(int i) const FINAL OVERRIDE { 2137 return inputs_[i]; 2138 } 2139 2140 void AddInput(HValue* value); 2141 2142 DECLARE_CONCRETE_INSTRUCTION(PushArguments) 2143 2144 protected: 2145 virtual void InternalSetOperandAt(int i, HValue* value) FINAL OVERRIDE { 2146 inputs_[i] = value; 2147 } 2148 2149 private: 2150 explicit HPushArguments(Zone* zone) 2151 : HInstruction(HType::Tagged()), inputs_(4, zone) { 2152 set_representation(Representation::Tagged()); 2153 } 2154 2155 ZoneList<HValue*> inputs_; 2156 }; 2157 2158 2159 class HThisFunction FINAL : public HTemplateInstruction<0> { 2160 public: 2161 DECLARE_INSTRUCTION_FACTORY_P0(HThisFunction); 2162 2163 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2164 return Representation::None(); 2165 } 2166 2167 DECLARE_CONCRETE_INSTRUCTION(ThisFunction) 2168 2169 protected: 2170 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 2171 2172 private: 2173 HThisFunction() { 2174 set_representation(Representation::Tagged()); 2175 SetFlag(kUseGVN); 2176 } 2177 2178 virtual bool IsDeletable() const OVERRIDE { return true; } 2179 }; 2180 2181 2182 class HDeclareGlobals FINAL : public HUnaryOperation { 2183 public: 2184 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HDeclareGlobals, 2185 Handle<FixedArray>, 2186 int); 2187 2188 HValue* context() { return OperandAt(0); } 2189 Handle<FixedArray> pairs() const { return pairs_; } 2190 int flags() const { return flags_; } 2191 2192 DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals) 2193 2194 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2195 return Representation::Tagged(); 2196 } 2197 2198 private: 2199 HDeclareGlobals(HValue* context, 2200 Handle<FixedArray> pairs, 2201 int flags) 2202 : HUnaryOperation(context), 2203 pairs_(pairs), 2204 flags_(flags) { 2205 set_representation(Representation::Tagged()); 2206 SetAllSideEffects(); 2207 } 2208 2209 Handle<FixedArray> pairs_; 2210 int flags_; 2211 }; 2212 2213 2214 template <int V> 2215 class HCall : public HTemplateInstruction<V> { 2216 public: 2217 // The argument count includes the receiver. 2218 explicit HCall<V>(int argument_count) : argument_count_(argument_count) { 2219 this->set_representation(Representation::Tagged()); 2220 this->SetAllSideEffects(); 2221 } 2222 2223 virtual HType CalculateInferredType() FINAL OVERRIDE { 2224 return HType::Tagged(); 2225 } 2226 2227 virtual int argument_count() const { 2228 return argument_count_; 2229 } 2230 2231 virtual int argument_delta() const OVERRIDE { 2232 return -argument_count(); 2233 } 2234 2235 private: 2236 int argument_count_; 2237 }; 2238 2239 2240 class HUnaryCall : public HCall<1> { 2241 public: 2242 HUnaryCall(HValue* value, int argument_count) 2243 : HCall<1>(argument_count) { 2244 SetOperandAt(0, value); 2245 } 2246 2247 virtual Representation RequiredInputRepresentation( 2248 int index) FINAL OVERRIDE { 2249 return Representation::Tagged(); 2250 } 2251 2252 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2253 2254 HValue* value() const { return OperandAt(0); } 2255 }; 2256 2257 2258 class HBinaryCall : public HCall<2> { 2259 public: 2260 HBinaryCall(HValue* first, HValue* second, int argument_count) 2261 : HCall<2>(argument_count) { 2262 SetOperandAt(0, first); 2263 SetOperandAt(1, second); 2264 } 2265 2266 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2267 2268 virtual Representation RequiredInputRepresentation( 2269 int index) FINAL OVERRIDE { 2270 return Representation::Tagged(); 2271 } 2272 2273 HValue* first() const { return OperandAt(0); } 2274 HValue* second() const { return OperandAt(1); } 2275 }; 2276 2277 2278 class HCallJSFunction FINAL : public HCall<1> { 2279 public: 2280 static HCallJSFunction* New(Zone* zone, 2281 HValue* context, 2282 HValue* function, 2283 int argument_count, 2284 bool pass_argument_count); 2285 2286 HValue* function() const { return OperandAt(0); } 2287 2288 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2289 2290 virtual Representation RequiredInputRepresentation( 2291 int index) FINAL OVERRIDE { 2292 DCHECK(index == 0); 2293 return Representation::Tagged(); 2294 } 2295 2296 bool pass_argument_count() const { return pass_argument_count_; } 2297 2298 virtual bool HasStackCheck() FINAL OVERRIDE { 2299 return has_stack_check_; 2300 } 2301 2302 DECLARE_CONCRETE_INSTRUCTION(CallJSFunction) 2303 2304 private: 2305 // The argument count includes the receiver. 2306 HCallJSFunction(HValue* function, 2307 int argument_count, 2308 bool pass_argument_count, 2309 bool has_stack_check) 2310 : HCall<1>(argument_count), 2311 pass_argument_count_(pass_argument_count), 2312 has_stack_check_(has_stack_check) { 2313 SetOperandAt(0, function); 2314 } 2315 2316 bool pass_argument_count_; 2317 bool has_stack_check_; 2318 }; 2319 2320 2321 class HCallWithDescriptor FINAL : public HInstruction { 2322 public: 2323 static HCallWithDescriptor* New(Zone* zone, HValue* context, HValue* target, 2324 int argument_count, 2325 CallInterfaceDescriptor descriptor, 2326 const Vector<HValue*>& operands) { 2327 DCHECK(operands.length() == descriptor.GetEnvironmentLength()); 2328 HCallWithDescriptor* res = new (zone) 2329 HCallWithDescriptor(target, argument_count, descriptor, operands, zone); 2330 return res; 2331 } 2332 2333 virtual int OperandCount() const FINAL OVERRIDE { 2334 return values_.length(); 2335 } 2336 virtual HValue* OperandAt(int index) const FINAL OVERRIDE { 2337 return values_[index]; 2338 } 2339 2340 virtual Representation RequiredInputRepresentation( 2341 int index) FINAL OVERRIDE { 2342 if (index == 0) { 2343 return Representation::Tagged(); 2344 } else { 2345 int par_index = index - 1; 2346 DCHECK(par_index < descriptor_.GetEnvironmentLength()); 2347 return descriptor_.GetParameterRepresentation(par_index); 2348 } 2349 } 2350 2351 DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor) 2352 2353 virtual HType CalculateInferredType() FINAL OVERRIDE { 2354 return HType::Tagged(); 2355 } 2356 2357 virtual int argument_count() const { 2358 return argument_count_; 2359 } 2360 2361 virtual int argument_delta() const OVERRIDE { 2362 return -argument_count_; 2363 } 2364 2365 CallInterfaceDescriptor descriptor() const { return descriptor_; } 2366 2367 HValue* target() { 2368 return OperandAt(0); 2369 } 2370 2371 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2372 2373 private: 2374 // The argument count includes the receiver. 2375 HCallWithDescriptor(HValue* target, int argument_count, 2376 CallInterfaceDescriptor descriptor, 2377 const Vector<HValue*>& operands, Zone* zone) 2378 : descriptor_(descriptor), 2379 values_(descriptor.GetEnvironmentLength() + 1, zone) { 2380 argument_count_ = argument_count; 2381 AddOperand(target, zone); 2382 for (int i = 0; i < operands.length(); i++) { 2383 AddOperand(operands[i], zone); 2384 } 2385 this->set_representation(Representation::Tagged()); 2386 this->SetAllSideEffects(); 2387 } 2388 2389 void AddOperand(HValue* v, Zone* zone) { 2390 values_.Add(NULL, zone); 2391 SetOperandAt(values_.length() - 1, v); 2392 } 2393 2394 void InternalSetOperandAt(int index, 2395 HValue* value) FINAL OVERRIDE { 2396 values_[index] = value; 2397 } 2398 2399 CallInterfaceDescriptor descriptor_; 2400 ZoneList<HValue*> values_; 2401 int argument_count_; 2402 }; 2403 2404 2405 class HInvokeFunction FINAL : public HBinaryCall { 2406 public: 2407 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInvokeFunction, HValue*, int); 2408 2409 HInvokeFunction(HValue* context, 2410 HValue* function, 2411 Handle<JSFunction> known_function, 2412 int argument_count) 2413 : HBinaryCall(context, function, argument_count), 2414 known_function_(known_function) { 2415 formal_parameter_count_ = known_function.is_null() 2416 ? 0 : known_function->shared()->formal_parameter_count(); 2417 has_stack_check_ = !known_function.is_null() && 2418 (known_function->code()->kind() == Code::FUNCTION || 2419 known_function->code()->kind() == Code::OPTIMIZED_FUNCTION); 2420 } 2421 2422 static HInvokeFunction* New(Zone* zone, 2423 HValue* context, 2424 HValue* function, 2425 Handle<JSFunction> known_function, 2426 int argument_count) { 2427 return new(zone) HInvokeFunction(context, function, 2428 known_function, argument_count); 2429 } 2430 2431 HValue* context() { return first(); } 2432 HValue* function() { return second(); } 2433 Handle<JSFunction> known_function() { return known_function_; } 2434 int formal_parameter_count() const { return formal_parameter_count_; } 2435 2436 virtual bool HasStackCheck() FINAL OVERRIDE { 2437 return has_stack_check_; 2438 } 2439 2440 DECLARE_CONCRETE_INSTRUCTION(InvokeFunction) 2441 2442 private: 2443 HInvokeFunction(HValue* context, HValue* function, int argument_count) 2444 : HBinaryCall(context, function, argument_count), 2445 has_stack_check_(false) { 2446 } 2447 2448 Handle<JSFunction> known_function_; 2449 int formal_parameter_count_; 2450 bool has_stack_check_; 2451 }; 2452 2453 2454 class HCallFunction FINAL : public HBinaryCall { 2455 public: 2456 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallFunction, HValue*, int); 2457 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3( 2458 HCallFunction, HValue*, int, CallFunctionFlags); 2459 2460 HValue* context() { return first(); } 2461 HValue* function() { return second(); } 2462 CallFunctionFlags function_flags() const { return function_flags_; } 2463 2464 DECLARE_CONCRETE_INSTRUCTION(CallFunction) 2465 2466 virtual int argument_delta() const OVERRIDE { return -argument_count(); } 2467 2468 private: 2469 HCallFunction(HValue* context, 2470 HValue* function, 2471 int argument_count, 2472 CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS) 2473 : HBinaryCall(context, function, argument_count), function_flags_(flags) { 2474 } 2475 CallFunctionFlags function_flags_; 2476 }; 2477 2478 2479 class HCallNew FINAL : public HBinaryCall { 2480 public: 2481 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallNew, HValue*, int); 2482 2483 HValue* context() { return first(); } 2484 HValue* constructor() { return second(); } 2485 2486 DECLARE_CONCRETE_INSTRUCTION(CallNew) 2487 2488 private: 2489 HCallNew(HValue* context, HValue* constructor, int argument_count) 2490 : HBinaryCall(context, constructor, argument_count) {} 2491 }; 2492 2493 2494 class HCallNewArray FINAL : public HBinaryCall { 2495 public: 2496 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCallNewArray, 2497 HValue*, 2498 int, 2499 ElementsKind); 2500 2501 HValue* context() { return first(); } 2502 HValue* constructor() { return second(); } 2503 2504 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2505 2506 ElementsKind elements_kind() const { return elements_kind_; } 2507 2508 DECLARE_CONCRETE_INSTRUCTION(CallNewArray) 2509 2510 private: 2511 HCallNewArray(HValue* context, HValue* constructor, int argument_count, 2512 ElementsKind elements_kind) 2513 : HBinaryCall(context, constructor, argument_count), 2514 elements_kind_(elements_kind) {} 2515 2516 ElementsKind elements_kind_; 2517 }; 2518 2519 2520 class HCallRuntime FINAL : public HCall<1> { 2521 public: 2522 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCallRuntime, 2523 Handle<String>, 2524 const Runtime::Function*, 2525 int); 2526 2527 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2528 2529 HValue* context() { return OperandAt(0); } 2530 const Runtime::Function* function() const { return c_function_; } 2531 Handle<String> name() const { return name_; } 2532 SaveFPRegsMode save_doubles() const { return save_doubles_; } 2533 void set_save_doubles(SaveFPRegsMode save_doubles) { 2534 save_doubles_ = save_doubles; 2535 } 2536 2537 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2538 return Representation::Tagged(); 2539 } 2540 2541 DECLARE_CONCRETE_INSTRUCTION(CallRuntime) 2542 2543 private: 2544 HCallRuntime(HValue* context, 2545 Handle<String> name, 2546 const Runtime::Function* c_function, 2547 int argument_count) 2548 : HCall<1>(argument_count), c_function_(c_function), name_(name), 2549 save_doubles_(kDontSaveFPRegs) { 2550 SetOperandAt(0, context); 2551 } 2552 2553 const Runtime::Function* c_function_; 2554 Handle<String> name_; 2555 SaveFPRegsMode save_doubles_; 2556 }; 2557 2558 2559 class HMapEnumLength FINAL : public HUnaryOperation { 2560 public: 2561 DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*); 2562 2563 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2564 return Representation::Tagged(); 2565 } 2566 2567 DECLARE_CONCRETE_INSTRUCTION(MapEnumLength) 2568 2569 protected: 2570 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 2571 2572 private: 2573 explicit HMapEnumLength(HValue* value) 2574 : HUnaryOperation(value, HType::Smi()) { 2575 set_representation(Representation::Smi()); 2576 SetFlag(kUseGVN); 2577 SetDependsOnFlag(kMaps); 2578 } 2579 2580 virtual bool IsDeletable() const OVERRIDE { return true; } 2581 }; 2582 2583 2584 class HUnaryMathOperation FINAL : public HTemplateInstruction<2> { 2585 public: 2586 static HInstruction* New(Zone* zone, 2587 HValue* context, 2588 HValue* value, 2589 BuiltinFunctionId op); 2590 2591 HValue* context() const { return OperandAt(0); } 2592 HValue* value() const { return OperandAt(1); } 2593 2594 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2595 2596 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2597 if (index == 0) { 2598 return Representation::Tagged(); 2599 } else { 2600 switch (op_) { 2601 case kMathFloor: 2602 case kMathRound: 2603 case kMathFround: 2604 case kMathSqrt: 2605 case kMathPowHalf: 2606 case kMathLog: 2607 case kMathExp: 2608 return Representation::Double(); 2609 case kMathAbs: 2610 return representation(); 2611 case kMathClz32: 2612 return Representation::Integer32(); 2613 default: 2614 UNREACHABLE(); 2615 return Representation::None(); 2616 } 2617 } 2618 } 2619 2620 virtual Range* InferRange(Zone* zone) OVERRIDE; 2621 2622 virtual HValue* Canonicalize() OVERRIDE; 2623 virtual Representation RepresentationFromUses() OVERRIDE; 2624 virtual Representation RepresentationFromInputs() OVERRIDE; 2625 2626 BuiltinFunctionId op() const { return op_; } 2627 const char* OpName() const; 2628 2629 DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation) 2630 2631 protected: 2632 virtual bool DataEquals(HValue* other) OVERRIDE { 2633 HUnaryMathOperation* b = HUnaryMathOperation::cast(other); 2634 return op_ == b->op(); 2635 } 2636 2637 private: 2638 // Indicates if we support a double (and int32) output for Math.floor and 2639 // Math.round. 2640 bool SupportsFlexibleFloorAndRound() const { 2641 #ifdef V8_TARGET_ARCH_ARM64 2642 return true; 2643 #else 2644 return false; 2645 #endif 2646 } 2647 HUnaryMathOperation(HValue* context, HValue* value, BuiltinFunctionId op) 2648 : HTemplateInstruction<2>(HType::TaggedNumber()), op_(op) { 2649 SetOperandAt(0, context); 2650 SetOperandAt(1, value); 2651 switch (op) { 2652 case kMathFloor: 2653 case kMathRound: 2654 if (SupportsFlexibleFloorAndRound()) { 2655 SetFlag(kFlexibleRepresentation); 2656 } else { 2657 set_representation(Representation::Integer32()); 2658 } 2659 break; 2660 case kMathClz32: 2661 set_representation(Representation::Integer32()); 2662 break; 2663 case kMathAbs: 2664 // Not setting representation here: it is None intentionally. 2665 SetFlag(kFlexibleRepresentation); 2666 // TODO(svenpanne) This flag is actually only needed if representation() 2667 // is tagged, and not when it is an unboxed double or unboxed integer. 2668 SetChangesFlag(kNewSpacePromotion); 2669 break; 2670 case kMathFround: 2671 case kMathLog: 2672 case kMathExp: 2673 case kMathSqrt: 2674 case kMathPowHalf: 2675 set_representation(Representation::Double()); 2676 break; 2677 default: 2678 UNREACHABLE(); 2679 } 2680 SetFlag(kUseGVN); 2681 SetFlag(kAllowUndefinedAsNaN); 2682 } 2683 2684 virtual bool IsDeletable() const OVERRIDE { return true; } 2685 2686 HValue* SimplifiedDividendForMathFloorOfDiv(HDiv* hdiv); 2687 HValue* SimplifiedDivisorForMathFloorOfDiv(HDiv* hdiv); 2688 2689 BuiltinFunctionId op_; 2690 }; 2691 2692 2693 class HLoadRoot FINAL : public HTemplateInstruction<0> { 2694 public: 2695 DECLARE_INSTRUCTION_FACTORY_P1(HLoadRoot, Heap::RootListIndex); 2696 DECLARE_INSTRUCTION_FACTORY_P2(HLoadRoot, Heap::RootListIndex, HType); 2697 2698 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2699 return Representation::None(); 2700 } 2701 2702 Heap::RootListIndex index() const { return index_; } 2703 2704 DECLARE_CONCRETE_INSTRUCTION(LoadRoot) 2705 2706 protected: 2707 virtual bool DataEquals(HValue* other) OVERRIDE { 2708 HLoadRoot* b = HLoadRoot::cast(other); 2709 return index_ == b->index_; 2710 } 2711 2712 private: 2713 explicit HLoadRoot(Heap::RootListIndex index, HType type = HType::Tagged()) 2714 : HTemplateInstruction<0>(type), index_(index) { 2715 SetFlag(kUseGVN); 2716 // TODO(bmeurer): We'll need kDependsOnRoots once we add the 2717 // corresponding HStoreRoot instruction. 2718 SetDependsOnFlag(kCalls); 2719 } 2720 2721 virtual bool IsDeletable() const OVERRIDE { return true; } 2722 2723 const Heap::RootListIndex index_; 2724 }; 2725 2726 2727 class HCheckMaps FINAL : public HTemplateInstruction<2> { 2728 public: 2729 static HCheckMaps* New(Zone* zone, HValue* context, HValue* value, 2730 Handle<Map> map, HValue* typecheck = NULL) { 2731 return new(zone) HCheckMaps(value, new(zone) UniqueSet<Map>( 2732 Unique<Map>::CreateImmovable(map), zone), typecheck); 2733 } 2734 static HCheckMaps* New(Zone* zone, HValue* context, 2735 HValue* value, SmallMapList* map_list, 2736 HValue* typecheck = NULL) { 2737 UniqueSet<Map>* maps = new(zone) UniqueSet<Map>(map_list->length(), zone); 2738 for (int i = 0; i < map_list->length(); ++i) { 2739 maps->Add(Unique<Map>::CreateImmovable(map_list->at(i)), zone); 2740 } 2741 return new(zone) HCheckMaps(value, maps, typecheck); 2742 } 2743 2744 bool IsStabilityCheck() const { return is_stability_check_; } 2745 void MarkAsStabilityCheck() { 2746 maps_are_stable_ = true; 2747 has_migration_target_ = false; 2748 is_stability_check_ = true; 2749 ClearChangesFlag(kNewSpacePromotion); 2750 ClearDependsOnFlag(kElementsKind); 2751 ClearDependsOnFlag(kMaps); 2752 } 2753 2754 virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; } 2755 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2756 return Representation::Tagged(); 2757 } 2758 2759 virtual HType CalculateInferredType() OVERRIDE { 2760 if (value()->type().IsHeapObject()) return value()->type(); 2761 return HType::HeapObject(); 2762 } 2763 2764 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2765 2766 HValue* value() const { return OperandAt(0); } 2767 HValue* typecheck() const { return OperandAt(1); } 2768 2769 const UniqueSet<Map>* maps() const { return maps_; } 2770 void set_maps(const UniqueSet<Map>* maps) { maps_ = maps; } 2771 2772 bool maps_are_stable() const { return maps_are_stable_; } 2773 2774 bool HasMigrationTarget() const { return has_migration_target_; } 2775 2776 virtual HValue* Canonicalize() OVERRIDE; 2777 2778 static HCheckMaps* CreateAndInsertAfter(Zone* zone, 2779 HValue* value, 2780 Unique<Map> map, 2781 bool map_is_stable, 2782 HInstruction* instr) { 2783 return instr->Append(new(zone) HCheckMaps( 2784 value, new(zone) UniqueSet<Map>(map, zone), map_is_stable)); 2785 } 2786 2787 static HCheckMaps* CreateAndInsertBefore(Zone* zone, 2788 HValue* value, 2789 const UniqueSet<Map>* maps, 2790 bool maps_are_stable, 2791 HInstruction* instr) { 2792 return instr->Prepend(new(zone) HCheckMaps(value, maps, maps_are_stable)); 2793 } 2794 2795 DECLARE_CONCRETE_INSTRUCTION(CheckMaps) 2796 2797 protected: 2798 virtual bool DataEquals(HValue* other) OVERRIDE { 2799 return this->maps()->Equals(HCheckMaps::cast(other)->maps()); 2800 } 2801 2802 virtual int RedefinedOperandIndex() { return 0; } 2803 2804 private: 2805 HCheckMaps(HValue* value, const UniqueSet<Map>* maps, bool maps_are_stable) 2806 : HTemplateInstruction<2>(HType::HeapObject()), maps_(maps), 2807 has_migration_target_(false), is_stability_check_(false), 2808 maps_are_stable_(maps_are_stable) { 2809 DCHECK_NE(0, maps->size()); 2810 SetOperandAt(0, value); 2811 // Use the object value for the dependency. 2812 SetOperandAt(1, value); 2813 set_representation(Representation::Tagged()); 2814 SetFlag(kUseGVN); 2815 SetDependsOnFlag(kMaps); 2816 SetDependsOnFlag(kElementsKind); 2817 } 2818 2819 HCheckMaps(HValue* value, const UniqueSet<Map>* maps, HValue* typecheck) 2820 : HTemplateInstruction<2>(HType::HeapObject()), maps_(maps), 2821 has_migration_target_(false), is_stability_check_(false), 2822 maps_are_stable_(true) { 2823 DCHECK_NE(0, maps->size()); 2824 SetOperandAt(0, value); 2825 // Use the object value for the dependency if NULL is passed. 2826 SetOperandAt(1, typecheck ? typecheck : value); 2827 set_representation(Representation::Tagged()); 2828 SetFlag(kUseGVN); 2829 SetDependsOnFlag(kMaps); 2830 SetDependsOnFlag(kElementsKind); 2831 for (int i = 0; i < maps->size(); ++i) { 2832 Handle<Map> map = maps->at(i).handle(); 2833 if (map->is_migration_target()) has_migration_target_ = true; 2834 if (!map->is_stable()) maps_are_stable_ = false; 2835 } 2836 if (has_migration_target_) SetChangesFlag(kNewSpacePromotion); 2837 } 2838 2839 const UniqueSet<Map>* maps_; 2840 bool has_migration_target_ : 1; 2841 bool is_stability_check_ : 1; 2842 bool maps_are_stable_ : 1; 2843 }; 2844 2845 2846 class HCheckValue FINAL : public HUnaryOperation { 2847 public: 2848 static HCheckValue* New(Zone* zone, HValue* context, 2849 HValue* value, Handle<JSFunction> func) { 2850 bool in_new_space = zone->isolate()->heap()->InNewSpace(*func); 2851 // NOTE: We create an uninitialized Unique and initialize it later. 2852 // This is because a JSFunction can move due to GC during graph creation. 2853 // TODO(titzer): This is a migration crutch. Replace with some kind of 2854 // Uniqueness scope later. 2855 Unique<JSFunction> target = Unique<JSFunction>::CreateUninitialized(func); 2856 HCheckValue* check = new(zone) HCheckValue(value, target, in_new_space); 2857 return check; 2858 } 2859 static HCheckValue* New(Zone* zone, HValue* context, 2860 HValue* value, Unique<HeapObject> target, 2861 bool object_in_new_space) { 2862 return new(zone) HCheckValue(value, target, object_in_new_space); 2863 } 2864 2865 virtual void FinalizeUniqueness() OVERRIDE { 2866 object_ = Unique<HeapObject>(object_.handle()); 2867 } 2868 2869 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2870 return Representation::Tagged(); 2871 } 2872 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2873 2874 virtual HValue* Canonicalize() OVERRIDE; 2875 2876 #ifdef DEBUG 2877 virtual void Verify() OVERRIDE; 2878 #endif 2879 2880 Unique<HeapObject> object() const { return object_; } 2881 bool object_in_new_space() const { return object_in_new_space_; } 2882 2883 DECLARE_CONCRETE_INSTRUCTION(CheckValue) 2884 2885 protected: 2886 virtual bool DataEquals(HValue* other) OVERRIDE { 2887 HCheckValue* b = HCheckValue::cast(other); 2888 return object_ == b->object_; 2889 } 2890 2891 private: 2892 HCheckValue(HValue* value, Unique<HeapObject> object, 2893 bool object_in_new_space) 2894 : HUnaryOperation(value, value->type()), 2895 object_(object), 2896 object_in_new_space_(object_in_new_space) { 2897 set_representation(Representation::Tagged()); 2898 SetFlag(kUseGVN); 2899 } 2900 2901 Unique<HeapObject> object_; 2902 bool object_in_new_space_; 2903 }; 2904 2905 2906 class HCheckInstanceType FINAL : public HUnaryOperation { 2907 public: 2908 enum Check { 2909 IS_SPEC_OBJECT, 2910 IS_JS_ARRAY, 2911 IS_STRING, 2912 IS_INTERNALIZED_STRING, 2913 LAST_INTERVAL_CHECK = IS_JS_ARRAY 2914 }; 2915 2916 DECLARE_INSTRUCTION_FACTORY_P2(HCheckInstanceType, HValue*, Check); 2917 2918 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 2919 2920 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2921 return Representation::Tagged(); 2922 } 2923 2924 virtual HType CalculateInferredType() OVERRIDE { 2925 switch (check_) { 2926 case IS_SPEC_OBJECT: return HType::JSObject(); 2927 case IS_JS_ARRAY: return HType::JSArray(); 2928 case IS_STRING: return HType::String(); 2929 case IS_INTERNALIZED_STRING: return HType::String(); 2930 } 2931 UNREACHABLE(); 2932 return HType::Tagged(); 2933 } 2934 2935 virtual HValue* Canonicalize() OVERRIDE; 2936 2937 bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; } 2938 void GetCheckInterval(InstanceType* first, InstanceType* last); 2939 void GetCheckMaskAndTag(uint8_t* mask, uint8_t* tag); 2940 2941 Check check() const { return check_; } 2942 2943 DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType) 2944 2945 protected: 2946 // TODO(ager): It could be nice to allow the ommision of instance 2947 // type checks if we have already performed an instance type check 2948 // with a larger range. 2949 virtual bool DataEquals(HValue* other) OVERRIDE { 2950 HCheckInstanceType* b = HCheckInstanceType::cast(other); 2951 return check_ == b->check_; 2952 } 2953 2954 virtual int RedefinedOperandIndex() { return 0; } 2955 2956 private: 2957 const char* GetCheckName() const; 2958 2959 HCheckInstanceType(HValue* value, Check check) 2960 : HUnaryOperation(value, HType::HeapObject()), check_(check) { 2961 set_representation(Representation::Tagged()); 2962 SetFlag(kUseGVN); 2963 } 2964 2965 const Check check_; 2966 }; 2967 2968 2969 class HCheckSmi FINAL : public HUnaryOperation { 2970 public: 2971 DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*); 2972 2973 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 2974 return Representation::Tagged(); 2975 } 2976 2977 virtual HValue* Canonicalize() OVERRIDE { 2978 HType value_type = value()->type(); 2979 if (value_type.IsSmi()) { 2980 return NULL; 2981 } 2982 return this; 2983 } 2984 2985 DECLARE_CONCRETE_INSTRUCTION(CheckSmi) 2986 2987 protected: 2988 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 2989 2990 private: 2991 explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) { 2992 set_representation(Representation::Smi()); 2993 SetFlag(kUseGVN); 2994 } 2995 }; 2996 2997 2998 class HCheckHeapObject FINAL : public HUnaryOperation { 2999 public: 3000 DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*); 3001 3002 virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; } 3003 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3004 return Representation::Tagged(); 3005 } 3006 3007 virtual HType CalculateInferredType() OVERRIDE { 3008 if (value()->type().IsHeapObject()) return value()->type(); 3009 return HType::HeapObject(); 3010 } 3011 3012 #ifdef DEBUG 3013 virtual void Verify() OVERRIDE; 3014 #endif 3015 3016 virtual HValue* Canonicalize() OVERRIDE { 3017 return value()->type().IsHeapObject() ? NULL : this; 3018 } 3019 3020 DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject) 3021 3022 protected: 3023 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 3024 3025 private: 3026 explicit HCheckHeapObject(HValue* value) : HUnaryOperation(value) { 3027 set_representation(Representation::Tagged()); 3028 SetFlag(kUseGVN); 3029 } 3030 }; 3031 3032 3033 class InductionVariableData; 3034 3035 3036 struct InductionVariableLimitUpdate { 3037 InductionVariableData* updated_variable; 3038 HValue* limit; 3039 bool limit_is_upper; 3040 bool limit_is_included; 3041 3042 InductionVariableLimitUpdate() 3043 : updated_variable(NULL), limit(NULL), 3044 limit_is_upper(false), limit_is_included(false) {} 3045 }; 3046 3047 3048 class HBoundsCheck; 3049 class HPhi; 3050 class HBitwise; 3051 3052 3053 class InductionVariableData FINAL : public ZoneObject { 3054 public: 3055 class InductionVariableCheck : public ZoneObject { 3056 public: 3057 HBoundsCheck* check() { return check_; } 3058 InductionVariableCheck* next() { return next_; } 3059 bool HasUpperLimit() { return upper_limit_ >= 0; } 3060 int32_t upper_limit() { 3061 DCHECK(HasUpperLimit()); 3062 return upper_limit_; 3063 } 3064 void set_upper_limit(int32_t upper_limit) { 3065 upper_limit_ = upper_limit; 3066 } 3067 3068 bool processed() { return processed_; } 3069 void set_processed() { processed_ = true; } 3070 3071 InductionVariableCheck(HBoundsCheck* check, 3072 InductionVariableCheck* next, 3073 int32_t upper_limit = kNoLimit) 3074 : check_(check), next_(next), upper_limit_(upper_limit), 3075 processed_(false) {} 3076 3077 private: 3078 HBoundsCheck* check_; 3079 InductionVariableCheck* next_; 3080 int32_t upper_limit_; 3081 bool processed_; 3082 }; 3083 3084 class ChecksRelatedToLength : public ZoneObject { 3085 public: 3086 HValue* length() { return length_; } 3087 ChecksRelatedToLength* next() { return next_; } 3088 InductionVariableCheck* checks() { return checks_; } 3089 3090 void AddCheck(HBoundsCheck* check, int32_t upper_limit = kNoLimit); 3091 void CloseCurrentBlock(); 3092 3093 ChecksRelatedToLength(HValue* length, ChecksRelatedToLength* next) 3094 : length_(length), next_(next), checks_(NULL), 3095 first_check_in_block_(NULL), 3096 added_index_(NULL), 3097 added_constant_(NULL), 3098 current_and_mask_in_block_(0), 3099 current_or_mask_in_block_(0) {} 3100 3101 private: 3102 void UseNewIndexInCurrentBlock(Token::Value token, 3103 int32_t mask, 3104 HValue* index_base, 3105 HValue* context); 3106 3107 HBoundsCheck* first_check_in_block() { return first_check_in_block_; } 3108 HBitwise* added_index() { return added_index_; } 3109 void set_added_index(HBitwise* index) { added_index_ = index; } 3110 HConstant* added_constant() { return added_constant_; } 3111 void set_added_constant(HConstant* constant) { added_constant_ = constant; } 3112 int32_t current_and_mask_in_block() { return current_and_mask_in_block_; } 3113 int32_t current_or_mask_in_block() { return current_or_mask_in_block_; } 3114 int32_t current_upper_limit() { return current_upper_limit_; } 3115 3116 HValue* length_; 3117 ChecksRelatedToLength* next_; 3118 InductionVariableCheck* checks_; 3119 3120 HBoundsCheck* first_check_in_block_; 3121 HBitwise* added_index_; 3122 HConstant* added_constant_; 3123 int32_t current_and_mask_in_block_; 3124 int32_t current_or_mask_in_block_; 3125 int32_t current_upper_limit_; 3126 }; 3127 3128 struct LimitFromPredecessorBlock { 3129 InductionVariableData* variable; 3130 Token::Value token; 3131 HValue* limit; 3132 HBasicBlock* other_target; 3133 3134 bool LimitIsValid() { return token != Token::ILLEGAL; } 3135 3136 bool LimitIsIncluded() { 3137 return Token::IsEqualityOp(token) || 3138 token == Token::GTE || token == Token::LTE; 3139 } 3140 bool LimitIsUpper() { 3141 return token == Token::LTE || token == Token::LT || token == Token::NE; 3142 } 3143 3144 LimitFromPredecessorBlock() 3145 : variable(NULL), 3146 token(Token::ILLEGAL), 3147 limit(NULL), 3148 other_target(NULL) {} 3149 }; 3150 3151 static const int32_t kNoLimit = -1; 3152 3153 static InductionVariableData* ExaminePhi(HPhi* phi); 3154 static void ComputeLimitFromPredecessorBlock( 3155 HBasicBlock* block, 3156 LimitFromPredecessorBlock* result); 3157 static bool ComputeInductionVariableLimit( 3158 HBasicBlock* block, 3159 InductionVariableLimitUpdate* additional_limit); 3160 3161 struct BitwiseDecompositionResult { 3162 HValue* base; 3163 int32_t and_mask; 3164 int32_t or_mask; 3165 HValue* context; 3166 3167 BitwiseDecompositionResult() 3168 : base(NULL), and_mask(0), or_mask(0), context(NULL) {} 3169 }; 3170 static void DecomposeBitwise(HValue* value, 3171 BitwiseDecompositionResult* result); 3172 3173 void AddCheck(HBoundsCheck* check, int32_t upper_limit = kNoLimit); 3174 3175 bool CheckIfBranchIsLoopGuard(Token::Value token, 3176 HBasicBlock* current_branch, 3177 HBasicBlock* other_branch); 3178 3179 void UpdateAdditionalLimit(InductionVariableLimitUpdate* update); 3180 3181 HPhi* phi() { return phi_; } 3182 HValue* base() { return base_; } 3183 int32_t increment() { return increment_; } 3184 HValue* limit() { return limit_; } 3185 bool limit_included() { return limit_included_; } 3186 HBasicBlock* limit_validity() { return limit_validity_; } 3187 HBasicBlock* induction_exit_block() { return induction_exit_block_; } 3188 HBasicBlock* induction_exit_target() { return induction_exit_target_; } 3189 ChecksRelatedToLength* checks() { return checks_; } 3190 HValue* additional_upper_limit() { return additional_upper_limit_; } 3191 bool additional_upper_limit_is_included() { 3192 return additional_upper_limit_is_included_; 3193 } 3194 HValue* additional_lower_limit() { return additional_lower_limit_; } 3195 bool additional_lower_limit_is_included() { 3196 return additional_lower_limit_is_included_; 3197 } 3198 3199 bool LowerLimitIsNonNegativeConstant() { 3200 if (base()->IsInteger32Constant() && base()->GetInteger32Constant() >= 0) { 3201 return true; 3202 } 3203 if (additional_lower_limit() != NULL && 3204 additional_lower_limit()->IsInteger32Constant() && 3205 additional_lower_limit()->GetInteger32Constant() >= 0) { 3206 // Ignoring the corner case of !additional_lower_limit_is_included() 3207 // is safe, handling it adds unneeded complexity. 3208 return true; 3209 } 3210 return false; 3211 } 3212 3213 int32_t ComputeUpperLimit(int32_t and_mask, int32_t or_mask); 3214 3215 private: 3216 template <class T> void swap(T* a, T* b) { 3217 T c(*a); 3218 *a = *b; 3219 *b = c; 3220 } 3221 3222 InductionVariableData(HPhi* phi, HValue* base, int32_t increment) 3223 : phi_(phi), base_(IgnoreOsrValue(base)), increment_(increment), 3224 limit_(NULL), limit_included_(false), limit_validity_(NULL), 3225 induction_exit_block_(NULL), induction_exit_target_(NULL), 3226 checks_(NULL), 3227 additional_upper_limit_(NULL), 3228 additional_upper_limit_is_included_(false), 3229 additional_lower_limit_(NULL), 3230 additional_lower_limit_is_included_(false) {} 3231 3232 static int32_t ComputeIncrement(HPhi* phi, HValue* phi_operand); 3233 3234 static HValue* IgnoreOsrValue(HValue* v); 3235 static InductionVariableData* GetInductionVariableData(HValue* v); 3236 3237 HPhi* phi_; 3238 HValue* base_; 3239 int32_t increment_; 3240 HValue* limit_; 3241 bool limit_included_; 3242 HBasicBlock* limit_validity_; 3243 HBasicBlock* induction_exit_block_; 3244 HBasicBlock* induction_exit_target_; 3245 ChecksRelatedToLength* checks_; 3246 HValue* additional_upper_limit_; 3247 bool additional_upper_limit_is_included_; 3248 HValue* additional_lower_limit_; 3249 bool additional_lower_limit_is_included_; 3250 }; 3251 3252 3253 class HPhi FINAL : public HValue { 3254 public: 3255 HPhi(int merged_index, Zone* zone) 3256 : inputs_(2, zone), 3257 merged_index_(merged_index), 3258 phi_id_(-1), 3259 induction_variable_data_(NULL) { 3260 for (int i = 0; i < Representation::kNumRepresentations; i++) { 3261 non_phi_uses_[i] = 0; 3262 indirect_uses_[i] = 0; 3263 } 3264 DCHECK(merged_index >= 0 || merged_index == kInvalidMergedIndex); 3265 SetFlag(kFlexibleRepresentation); 3266 SetFlag(kAllowUndefinedAsNaN); 3267 } 3268 3269 virtual Representation RepresentationFromInputs() OVERRIDE; 3270 3271 virtual Range* InferRange(Zone* zone) OVERRIDE; 3272 virtual void InferRepresentation( 3273 HInferRepresentationPhase* h_infer) OVERRIDE; 3274 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3275 return representation(); 3276 } 3277 virtual Representation KnownOptimalRepresentation() OVERRIDE { 3278 return representation(); 3279 } 3280 virtual HType CalculateInferredType() OVERRIDE; 3281 virtual int OperandCount() const OVERRIDE { return inputs_.length(); } 3282 virtual HValue* OperandAt(int index) const OVERRIDE { 3283 return inputs_[index]; 3284 } 3285 HValue* GetRedundantReplacement(); 3286 void AddInput(HValue* value); 3287 bool HasRealUses(); 3288 3289 bool IsReceiver() const { return merged_index_ == 0; } 3290 bool HasMergedIndex() const { return merged_index_ != kInvalidMergedIndex; } 3291 3292 virtual HSourcePosition position() const OVERRIDE; 3293 3294 int merged_index() const { return merged_index_; } 3295 3296 InductionVariableData* induction_variable_data() { 3297 return induction_variable_data_; 3298 } 3299 bool IsInductionVariable() { 3300 return induction_variable_data_ != NULL; 3301 } 3302 bool IsLimitedInductionVariable() { 3303 return IsInductionVariable() && 3304 induction_variable_data_->limit() != NULL; 3305 } 3306 void DetectInductionVariable() { 3307 DCHECK(induction_variable_data_ == NULL); 3308 induction_variable_data_ = InductionVariableData::ExaminePhi(this); 3309 } 3310 3311 virtual OStream& PrintTo(OStream& os) const OVERRIDE; // NOLINT 3312 3313 #ifdef DEBUG 3314 virtual void Verify() OVERRIDE; 3315 #endif 3316 3317 void InitRealUses(int id); 3318 void AddNonPhiUsesFrom(HPhi* other); 3319 void AddIndirectUsesTo(int* use_count); 3320 3321 int tagged_non_phi_uses() const { 3322 return non_phi_uses_[Representation::kTagged]; 3323 } 3324 int smi_non_phi_uses() const { 3325 return non_phi_uses_[Representation::kSmi]; 3326 } 3327 int int32_non_phi_uses() const { 3328 return non_phi_uses_[Representation::kInteger32]; 3329 } 3330 int double_non_phi_uses() const { 3331 return non_phi_uses_[Representation::kDouble]; 3332 } 3333 int tagged_indirect_uses() const { 3334 return indirect_uses_[Representation::kTagged]; 3335 } 3336 int smi_indirect_uses() const { 3337 return indirect_uses_[Representation::kSmi]; 3338 } 3339 int int32_indirect_uses() const { 3340 return indirect_uses_[Representation::kInteger32]; 3341 } 3342 int double_indirect_uses() const { 3343 return indirect_uses_[Representation::kDouble]; 3344 } 3345 int phi_id() { return phi_id_; } 3346 3347 static HPhi* cast(HValue* value) { 3348 DCHECK(value->IsPhi()); 3349 return reinterpret_cast<HPhi*>(value); 3350 } 3351 virtual Opcode opcode() const OVERRIDE { return HValue::kPhi; } 3352 3353 void SimplifyConstantInputs(); 3354 3355 // Marker value representing an invalid merge index. 3356 static const int kInvalidMergedIndex = -1; 3357 3358 protected: 3359 virtual void DeleteFromGraph() OVERRIDE; 3360 virtual void InternalSetOperandAt(int index, HValue* value) OVERRIDE { 3361 inputs_[index] = value; 3362 } 3363 3364 private: 3365 ZoneList<HValue*> inputs_; 3366 int merged_index_; 3367 3368 int non_phi_uses_[Representation::kNumRepresentations]; 3369 int indirect_uses_[Representation::kNumRepresentations]; 3370 int phi_id_; 3371 InductionVariableData* induction_variable_data_; 3372 3373 // TODO(titzer): we can't eliminate the receiver for generating backtraces 3374 virtual bool IsDeletable() const OVERRIDE { return !IsReceiver(); } 3375 }; 3376 3377 3378 // Common base class for HArgumentsObject and HCapturedObject. 3379 class HDematerializedObject : public HInstruction { 3380 public: 3381 HDematerializedObject(int count, Zone* zone) : values_(count, zone) {} 3382 3383 virtual int OperandCount() const FINAL OVERRIDE { 3384 return values_.length(); 3385 } 3386 virtual HValue* OperandAt(int index) const FINAL OVERRIDE { 3387 return values_[index]; 3388 } 3389 3390 virtual bool HasEscapingOperandAt(int index) FINAL OVERRIDE { 3391 return false; 3392 } 3393 virtual Representation RequiredInputRepresentation( 3394 int index) FINAL OVERRIDE { 3395 return Representation::None(); 3396 } 3397 3398 protected: 3399 virtual void InternalSetOperandAt(int index, 3400 HValue* value) FINAL OVERRIDE { 3401 values_[index] = value; 3402 } 3403 3404 // List of values tracked by this marker. 3405 ZoneList<HValue*> values_; 3406 }; 3407 3408 3409 class HArgumentsObject FINAL : public HDematerializedObject { 3410 public: 3411 static HArgumentsObject* New(Zone* zone, HValue* context, int count) { 3412 return new(zone) HArgumentsObject(count, zone); 3413 } 3414 3415 // The values contain a list of all elements in the arguments object 3416 // including the receiver object, which is skipped when materializing. 3417 const ZoneList<HValue*>* arguments_values() const { return &values_; } 3418 int arguments_count() const { return values_.length(); } 3419 3420 void AddArgument(HValue* argument, Zone* zone) { 3421 values_.Add(NULL, zone); // Resize list. 3422 SetOperandAt(values_.length() - 1, argument); 3423 } 3424 3425 DECLARE_CONCRETE_INSTRUCTION(ArgumentsObject) 3426 3427 private: 3428 HArgumentsObject(int count, Zone* zone) 3429 : HDematerializedObject(count, zone) { 3430 set_representation(Representation::Tagged()); 3431 SetFlag(kIsArguments); 3432 } 3433 }; 3434 3435 3436 class HCapturedObject FINAL : public HDematerializedObject { 3437 public: 3438 HCapturedObject(int length, int id, Zone* zone) 3439 : HDematerializedObject(length, zone), capture_id_(id) { 3440 set_representation(Representation::Tagged()); 3441 values_.AddBlock(NULL, length, zone); // Resize list. 3442 } 3443 3444 // The values contain a list of all in-object properties inside the 3445 // captured object and is index by field index. Properties in the 3446 // properties or elements backing store are not tracked here. 3447 const ZoneList<HValue*>* values() const { return &values_; } 3448 int length() const { return values_.length(); } 3449 int capture_id() const { return capture_id_; } 3450 3451 // Shortcut for the map value of this captured object. 3452 HValue* map_value() const { return values()->first(); } 3453 3454 void ReuseSideEffectsFromStore(HInstruction* store) { 3455 DCHECK(store->HasObservableSideEffects()); 3456 DCHECK(store->IsStoreNamedField()); 3457 changes_flags_.Add(store->ChangesFlags()); 3458 } 3459 3460 // Replay effects of this instruction on the given environment. 3461 void ReplayEnvironment(HEnvironment* env); 3462 3463 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 3464 3465 DECLARE_CONCRETE_INSTRUCTION(CapturedObject) 3466 3467 private: 3468 int capture_id_; 3469 3470 // Note that we cannot DCE captured objects as they are used to replay 3471 // the environment. This method is here as an explicit reminder. 3472 // TODO(mstarzinger): Turn HSimulates into full snapshots maybe? 3473 virtual bool IsDeletable() const FINAL OVERRIDE { return false; } 3474 }; 3475 3476 3477 class HConstant FINAL : public HTemplateInstruction<0> { 3478 public: 3479 DECLARE_INSTRUCTION_FACTORY_P1(HConstant, int32_t); 3480 DECLARE_INSTRUCTION_FACTORY_P2(HConstant, int32_t, Representation); 3481 DECLARE_INSTRUCTION_FACTORY_P1(HConstant, double); 3482 DECLARE_INSTRUCTION_FACTORY_P1(HConstant, Handle<Object>); 3483 DECLARE_INSTRUCTION_FACTORY_P1(HConstant, ExternalReference); 3484 3485 static HConstant* CreateAndInsertAfter(Zone* zone, 3486 HValue* context, 3487 int32_t value, 3488 Representation representation, 3489 HInstruction* instruction) { 3490 return instruction->Append(HConstant::New( 3491 zone, context, value, representation)); 3492 } 3493 3494 virtual Handle<Map> GetMonomorphicJSObjectMap() OVERRIDE { 3495 Handle<Object> object = object_.handle(); 3496 if (!object.is_null() && object->IsHeapObject()) { 3497 return v8::internal::handle(HeapObject::cast(*object)->map()); 3498 } 3499 return Handle<Map>(); 3500 } 3501 3502 static HConstant* CreateAndInsertBefore(Zone* zone, 3503 HValue* context, 3504 int32_t value, 3505 Representation representation, 3506 HInstruction* instruction) { 3507 return instruction->Prepend(HConstant::New( 3508 zone, context, value, representation)); 3509 } 3510 3511 static HConstant* CreateAndInsertBefore(Zone* zone, 3512 Unique<Map> map, 3513 bool map_is_stable, 3514 HInstruction* instruction) { 3515 return instruction->Prepend(new(zone) HConstant( 3516 map, Unique<Map>(Handle<Map>::null()), map_is_stable, 3517 Representation::Tagged(), HType::HeapObject(), true, 3518 false, false, MAP_TYPE)); 3519 } 3520 3521 static HConstant* CreateAndInsertAfter(Zone* zone, 3522 Unique<Map> map, 3523 bool map_is_stable, 3524 HInstruction* instruction) { 3525 return instruction->Append(new(zone) HConstant( 3526 map, Unique<Map>(Handle<Map>::null()), map_is_stable, 3527 Representation::Tagged(), HType::HeapObject(), true, 3528 false, false, MAP_TYPE)); 3529 } 3530 3531 Handle<Object> handle(Isolate* isolate) { 3532 if (object_.handle().is_null()) { 3533 // Default arguments to is_not_in_new_space depend on this heap number 3534 // to be tenured so that it's guaranteed not to be located in new space. 3535 object_ = Unique<Object>::CreateUninitialized( 3536 isolate->factory()->NewNumber(double_value_, TENURED)); 3537 } 3538 AllowDeferredHandleDereference smi_check; 3539 DCHECK(has_int32_value_ || !object_.handle()->IsSmi()); 3540 return object_.handle(); 3541 } 3542 3543 bool IsSpecialDouble() const { 3544 return has_double_value_ && 3545 (bit_cast<int64_t>(double_value_) == bit_cast<int64_t>(-0.0) || 3546 FixedDoubleArray::is_the_hole_nan(double_value_) || 3547 std::isnan(double_value_)); 3548 } 3549 3550 bool NotInNewSpace() const { 3551 return is_not_in_new_space_; 3552 } 3553 3554 bool ImmortalImmovable() const; 3555 3556 bool IsCell() const { 3557 return instance_type_ == CELL_TYPE || instance_type_ == PROPERTY_CELL_TYPE; 3558 } 3559 3560 bool IsMap() const { 3561 return instance_type_ == MAP_TYPE; 3562 } 3563 3564 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3565 return Representation::None(); 3566 } 3567 3568 virtual Representation KnownOptimalRepresentation() OVERRIDE { 3569 if (HasSmiValue() && SmiValuesAre31Bits()) return Representation::Smi(); 3570 if (HasInteger32Value()) return Representation::Integer32(); 3571 if (HasNumberValue()) return Representation::Double(); 3572 if (HasExternalReferenceValue()) return Representation::External(); 3573 return Representation::Tagged(); 3574 } 3575 3576 virtual bool EmitAtUses() OVERRIDE; 3577 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 3578 HConstant* CopyToRepresentation(Representation r, Zone* zone) const; 3579 Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone); 3580 Maybe<HConstant*> CopyToTruncatedNumber(Zone* zone); 3581 bool HasInteger32Value() const { return has_int32_value_; } 3582 int32_t Integer32Value() const { 3583 DCHECK(HasInteger32Value()); 3584 return int32_value_; 3585 } 3586 bool HasSmiValue() const { return has_smi_value_; } 3587 bool HasDoubleValue() const { return has_double_value_; } 3588 double DoubleValue() const { 3589 DCHECK(HasDoubleValue()); 3590 return double_value_; 3591 } 3592 bool IsTheHole() const { 3593 if (HasDoubleValue() && FixedDoubleArray::is_the_hole_nan(double_value_)) { 3594 return true; 3595 } 3596 return object_.IsInitialized() && 3597 object_.IsKnownGlobal(isolate()->heap()->the_hole_value()); 3598 } 3599 bool HasNumberValue() const { return has_double_value_; } 3600 int32_t NumberValueAsInteger32() const { 3601 DCHECK(HasNumberValue()); 3602 // Irrespective of whether a numeric HConstant can be safely 3603 // represented as an int32, we store the (in some cases lossy) 3604 // representation of the number in int32_value_. 3605 return int32_value_; 3606 } 3607 bool HasStringValue() const { 3608 if (has_double_value_ || has_int32_value_) return false; 3609 DCHECK(!object_.handle().is_null()); 3610 return instance_type_ < FIRST_NONSTRING_TYPE; 3611 } 3612 Handle<String> StringValue() const { 3613 DCHECK(HasStringValue()); 3614 return Handle<String>::cast(object_.handle()); 3615 } 3616 bool HasInternalizedStringValue() const { 3617 return HasStringValue() && StringShape(instance_type_).IsInternalized(); 3618 } 3619 3620 bool HasExternalReferenceValue() const { 3621 return has_external_reference_value_; 3622 } 3623 ExternalReference ExternalReferenceValue() const { 3624 return external_reference_value_; 3625 } 3626 3627 bool HasBooleanValue() const { return type_.IsBoolean(); } 3628 bool BooleanValue() const { return boolean_value_; } 3629 bool IsUndetectable() const { return is_undetectable_; } 3630 InstanceType GetInstanceType() const { return instance_type_; } 3631 3632 bool HasMapValue() const { return instance_type_ == MAP_TYPE; } 3633 Unique<Map> MapValue() const { 3634 DCHECK(HasMapValue()); 3635 return Unique<Map>::cast(GetUnique()); 3636 } 3637 bool HasStableMapValue() const { 3638 DCHECK(HasMapValue() || !has_stable_map_value_); 3639 return has_stable_map_value_; 3640 } 3641 3642 bool HasObjectMap() const { return !object_map_.IsNull(); } 3643 Unique<Map> ObjectMap() const { 3644 DCHECK(HasObjectMap()); 3645 return object_map_; 3646 } 3647 3648 virtual intptr_t Hashcode() OVERRIDE { 3649 if (has_int32_value_) { 3650 return static_cast<intptr_t>(int32_value_); 3651 } else if (has_double_value_) { 3652 return static_cast<intptr_t>(bit_cast<int64_t>(double_value_)); 3653 } else if (has_external_reference_value_) { 3654 return reinterpret_cast<intptr_t>(external_reference_value_.address()); 3655 } else { 3656 DCHECK(!object_.handle().is_null()); 3657 return object_.Hashcode(); 3658 } 3659 } 3660 3661 virtual void FinalizeUniqueness() OVERRIDE { 3662 if (!has_double_value_ && !has_external_reference_value_) { 3663 DCHECK(!object_.handle().is_null()); 3664 object_ = Unique<Object>(object_.handle()); 3665 } 3666 } 3667 3668 Unique<Object> GetUnique() const { 3669 return object_; 3670 } 3671 3672 bool EqualsUnique(Unique<Object> other) const { 3673 return object_.IsInitialized() && object_ == other; 3674 } 3675 3676 virtual bool DataEquals(HValue* other) OVERRIDE { 3677 HConstant* other_constant = HConstant::cast(other); 3678 if (has_int32_value_) { 3679 return other_constant->has_int32_value_ && 3680 int32_value_ == other_constant->int32_value_; 3681 } else if (has_double_value_) { 3682 return other_constant->has_double_value_ && 3683 bit_cast<int64_t>(double_value_) == 3684 bit_cast<int64_t>(other_constant->double_value_); 3685 } else if (has_external_reference_value_) { 3686 return other_constant->has_external_reference_value_ && 3687 external_reference_value_ == 3688 other_constant->external_reference_value_; 3689 } else { 3690 if (other_constant->has_int32_value_ || 3691 other_constant->has_double_value_ || 3692 other_constant->has_external_reference_value_) { 3693 return false; 3694 } 3695 DCHECK(!object_.handle().is_null()); 3696 return other_constant->object_ == object_; 3697 } 3698 } 3699 3700 #ifdef DEBUG 3701 virtual void Verify() OVERRIDE { } 3702 #endif 3703 3704 DECLARE_CONCRETE_INSTRUCTION(Constant) 3705 3706 protected: 3707 virtual Range* InferRange(Zone* zone) OVERRIDE; 3708 3709 private: 3710 friend class HGraph; 3711 explicit HConstant(Handle<Object> handle, 3712 Representation r = Representation::None()); 3713 HConstant(int32_t value, 3714 Representation r = Representation::None(), 3715 bool is_not_in_new_space = true, 3716 Unique<Object> optional = Unique<Object>(Handle<Object>::null())); 3717 HConstant(double value, 3718 Representation r = Representation::None(), 3719 bool is_not_in_new_space = true, 3720 Unique<Object> optional = Unique<Object>(Handle<Object>::null())); 3721 HConstant(Unique<Object> object, 3722 Unique<Map> object_map, 3723 bool has_stable_map_value, 3724 Representation r, 3725 HType type, 3726 bool is_not_in_new_space, 3727 bool boolean_value, 3728 bool is_undetectable, 3729 InstanceType instance_type); 3730 3731 explicit HConstant(ExternalReference reference); 3732 3733 void Initialize(Representation r); 3734 3735 virtual bool IsDeletable() const OVERRIDE { return true; } 3736 3737 // If this is a numerical constant, object_ either points to the 3738 // HeapObject the constant originated from or is null. If the 3739 // constant is non-numeric, object_ always points to a valid 3740 // constant HeapObject. 3741 Unique<Object> object_; 3742 3743 // If object_ is a heap object, this points to the stable map of the object. 3744 Unique<Map> object_map_; 3745 3746 // If object_ is a map, this indicates whether the map is stable. 3747 bool has_stable_map_value_ : 1; 3748 3749 // We store the HConstant in the most specific form safely possible. 3750 // The two flags, has_int32_value_ and has_double_value_ tell us if 3751 // int32_value_ and double_value_ hold valid, safe representations 3752 // of the constant. has_int32_value_ implies has_double_value_ but 3753 // not the converse. 3754 bool has_smi_value_ : 1; 3755 bool has_int32_value_ : 1; 3756 bool has_double_value_ : 1; 3757 bool has_external_reference_value_ : 1; 3758 bool is_not_in_new_space_ : 1; 3759 bool boolean_value_ : 1; 3760 bool is_undetectable_: 1; 3761 int32_t int32_value_; 3762 double double_value_; 3763 ExternalReference external_reference_value_; 3764 3765 static const InstanceType kUnknownInstanceType = FILLER_TYPE; 3766 InstanceType instance_type_; 3767 }; 3768 3769 3770 class HBinaryOperation : public HTemplateInstruction<3> { 3771 public: 3772 HBinaryOperation(HValue* context, HValue* left, HValue* right, 3773 HType type = HType::Tagged()) 3774 : HTemplateInstruction<3>(type), 3775 observed_output_representation_(Representation::None()) { 3776 DCHECK(left != NULL && right != NULL); 3777 SetOperandAt(0, context); 3778 SetOperandAt(1, left); 3779 SetOperandAt(2, right); 3780 observed_input_representation_[0] = Representation::None(); 3781 observed_input_representation_[1] = Representation::None(); 3782 } 3783 3784 HValue* context() const { return OperandAt(0); } 3785 HValue* left() const { return OperandAt(1); } 3786 HValue* right() const { return OperandAt(2); } 3787 3788 // True if switching left and right operands likely generates better code. 3789 bool AreOperandsBetterSwitched() { 3790 if (!IsCommutative()) return false; 3791 3792 // Constant operands are better off on the right, they can be inlined in 3793 // many situations on most platforms. 3794 if (left()->IsConstant()) return true; 3795 if (right()->IsConstant()) return false; 3796 3797 // Otherwise, if there is only one use of the right operand, it would be 3798 // better off on the left for platforms that only have 2-arg arithmetic 3799 // ops (e.g ia32, x64) that clobber the left operand. 3800 return right()->HasOneUse(); 3801 } 3802 3803 HValue* BetterLeftOperand() { 3804 return AreOperandsBetterSwitched() ? right() : left(); 3805 } 3806 3807 HValue* BetterRightOperand() { 3808 return AreOperandsBetterSwitched() ? left() : right(); 3809 } 3810 3811 void set_observed_input_representation(int index, Representation rep) { 3812 DCHECK(index >= 1 && index <= 2); 3813 observed_input_representation_[index - 1] = rep; 3814 } 3815 3816 virtual void initialize_output_representation(Representation observed) { 3817 observed_output_representation_ = observed; 3818 } 3819 3820 virtual Representation observed_input_representation(int index) OVERRIDE { 3821 if (index == 0) return Representation::Tagged(); 3822 return observed_input_representation_[index - 1]; 3823 } 3824 3825 virtual void UpdateRepresentation(Representation new_rep, 3826 HInferRepresentationPhase* h_infer, 3827 const char* reason) OVERRIDE { 3828 Representation rep = !FLAG_smi_binop && new_rep.IsSmi() 3829 ? Representation::Integer32() : new_rep; 3830 HValue::UpdateRepresentation(rep, h_infer, reason); 3831 } 3832 3833 virtual void InferRepresentation( 3834 HInferRepresentationPhase* h_infer) OVERRIDE; 3835 virtual Representation RepresentationFromInputs() OVERRIDE; 3836 Representation RepresentationFromOutput(); 3837 virtual void AssumeRepresentation(Representation r) OVERRIDE; 3838 3839 virtual bool IsCommutative() const { return false; } 3840 3841 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 3842 3843 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3844 if (index == 0) return Representation::Tagged(); 3845 return representation(); 3846 } 3847 3848 void SetOperandPositions(Zone* zone, 3849 HSourcePosition left_pos, 3850 HSourcePosition right_pos) { 3851 set_operand_position(zone, 1, left_pos); 3852 set_operand_position(zone, 2, right_pos); 3853 } 3854 3855 bool RightIsPowerOf2() { 3856 if (!right()->IsInteger32Constant()) return false; 3857 int32_t value = right()->GetInteger32Constant(); 3858 if (value < 0) { 3859 return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(-value)); 3860 } 3861 return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(value)); 3862 } 3863 3864 DECLARE_ABSTRACT_INSTRUCTION(BinaryOperation) 3865 3866 private: 3867 bool IgnoreObservedOutputRepresentation(Representation current_rep); 3868 3869 Representation observed_input_representation_[2]; 3870 Representation observed_output_representation_; 3871 }; 3872 3873 3874 class HWrapReceiver FINAL : public HTemplateInstruction<2> { 3875 public: 3876 DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*); 3877 3878 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 3879 3880 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3881 return Representation::Tagged(); 3882 } 3883 3884 HValue* receiver() const { return OperandAt(0); } 3885 HValue* function() const { return OperandAt(1); } 3886 3887 virtual HValue* Canonicalize() OVERRIDE; 3888 3889 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 3890 bool known_function() const { return known_function_; } 3891 3892 DECLARE_CONCRETE_INSTRUCTION(WrapReceiver) 3893 3894 private: 3895 HWrapReceiver(HValue* receiver, HValue* function) { 3896 known_function_ = function->IsConstant() && 3897 HConstant::cast(function)->handle(function->isolate())->IsJSFunction(); 3898 set_representation(Representation::Tagged()); 3899 SetOperandAt(0, receiver); 3900 SetOperandAt(1, function); 3901 SetFlag(kUseGVN); 3902 } 3903 3904 bool known_function_; 3905 }; 3906 3907 3908 class HApplyArguments FINAL : public HTemplateInstruction<4> { 3909 public: 3910 DECLARE_INSTRUCTION_FACTORY_P4(HApplyArguments, HValue*, HValue*, HValue*, 3911 HValue*); 3912 3913 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3914 // The length is untagged, all other inputs are tagged. 3915 return (index == 2) 3916 ? Representation::Integer32() 3917 : Representation::Tagged(); 3918 } 3919 3920 HValue* function() { return OperandAt(0); } 3921 HValue* receiver() { return OperandAt(1); } 3922 HValue* length() { return OperandAt(2); } 3923 HValue* elements() { return OperandAt(3); } 3924 3925 DECLARE_CONCRETE_INSTRUCTION(ApplyArguments) 3926 3927 private: 3928 HApplyArguments(HValue* function, 3929 HValue* receiver, 3930 HValue* length, 3931 HValue* elements) { 3932 set_representation(Representation::Tagged()); 3933 SetOperandAt(0, function); 3934 SetOperandAt(1, receiver); 3935 SetOperandAt(2, length); 3936 SetOperandAt(3, elements); 3937 SetAllSideEffects(); 3938 } 3939 }; 3940 3941 3942 class HArgumentsElements FINAL : public HTemplateInstruction<0> { 3943 public: 3944 DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool); 3945 3946 DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements) 3947 3948 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3949 return Representation::None(); 3950 } 3951 3952 bool from_inlined() const { return from_inlined_; } 3953 3954 protected: 3955 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 3956 3957 private: 3958 explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) { 3959 // The value produced by this instruction is a pointer into the stack 3960 // that looks as if it was a smi because of alignment. 3961 set_representation(Representation::Tagged()); 3962 SetFlag(kUseGVN); 3963 } 3964 3965 virtual bool IsDeletable() const OVERRIDE { return true; } 3966 3967 bool from_inlined_; 3968 }; 3969 3970 3971 class HArgumentsLength FINAL : public HUnaryOperation { 3972 public: 3973 DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*); 3974 3975 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 3976 return Representation::Tagged(); 3977 } 3978 3979 DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength) 3980 3981 protected: 3982 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 3983 3984 private: 3985 explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) { 3986 set_representation(Representation::Integer32()); 3987 SetFlag(kUseGVN); 3988 } 3989 3990 virtual bool IsDeletable() const OVERRIDE { return true; } 3991 }; 3992 3993 3994 class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> { 3995 public: 3996 DECLARE_INSTRUCTION_FACTORY_P3(HAccessArgumentsAt, HValue*, HValue*, HValue*); 3997 3998 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 3999 4000 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4001 // The arguments elements is considered tagged. 4002 return index == 0 4003 ? Representation::Tagged() 4004 : Representation::Integer32(); 4005 } 4006 4007 HValue* arguments() const { return OperandAt(0); } 4008 HValue* length() const { return OperandAt(1); } 4009 HValue* index() const { return OperandAt(2); } 4010 4011 DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt) 4012 4013 private: 4014 HAccessArgumentsAt(HValue* arguments, HValue* length, HValue* index) { 4015 set_representation(Representation::Tagged()); 4016 SetFlag(kUseGVN); 4017 SetOperandAt(0, arguments); 4018 SetOperandAt(1, length); 4019 SetOperandAt(2, index); 4020 } 4021 4022 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4023 }; 4024 4025 4026 class HBoundsCheckBaseIndexInformation; 4027 4028 4029 class HBoundsCheck FINAL : public HTemplateInstruction<2> { 4030 public: 4031 DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*); 4032 4033 bool skip_check() const { return skip_check_; } 4034 void set_skip_check() { skip_check_ = true; } 4035 4036 HValue* base() const { return base_; } 4037 int offset() const { return offset_; } 4038 int scale() const { return scale_; } 4039 4040 void ApplyIndexChange(); 4041 bool DetectCompoundIndex() { 4042 DCHECK(base() == NULL); 4043 4044 DecompositionResult decomposition; 4045 if (index()->TryDecompose(&decomposition)) { 4046 base_ = decomposition.base(); 4047 offset_ = decomposition.offset(); 4048 scale_ = decomposition.scale(); 4049 return true; 4050 } else { 4051 base_ = index(); 4052 offset_ = 0; 4053 scale_ = 0; 4054 return false; 4055 } 4056 } 4057 4058 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4059 return representation(); 4060 } 4061 4062 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4063 virtual void InferRepresentation( 4064 HInferRepresentationPhase* h_infer) OVERRIDE; 4065 4066 HValue* index() const { return OperandAt(0); } 4067 HValue* length() const { return OperandAt(1); } 4068 bool allow_equality() const { return allow_equality_; } 4069 void set_allow_equality(bool v) { allow_equality_ = v; } 4070 4071 virtual int RedefinedOperandIndex() OVERRIDE { return 0; } 4072 virtual bool IsPurelyInformativeDefinition() OVERRIDE { 4073 return skip_check(); 4074 } 4075 4076 DECLARE_CONCRETE_INSTRUCTION(BoundsCheck) 4077 4078 protected: 4079 friend class HBoundsCheckBaseIndexInformation; 4080 4081 virtual Range* InferRange(Zone* zone) OVERRIDE; 4082 4083 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4084 bool skip_check_; 4085 HValue* base_; 4086 int offset_; 4087 int scale_; 4088 bool allow_equality_; 4089 4090 private: 4091 // Normally HBoundsCheck should be created using the 4092 // HGraphBuilder::AddBoundsCheck() helper. 4093 // However when building stubs, where we know that the arguments are Int32, 4094 // it makes sense to invoke this constructor directly. 4095 HBoundsCheck(HValue* index, HValue* length) 4096 : skip_check_(false), 4097 base_(NULL), offset_(0), scale_(0), 4098 allow_equality_(false) { 4099 SetOperandAt(0, index); 4100 SetOperandAt(1, length); 4101 SetFlag(kFlexibleRepresentation); 4102 SetFlag(kUseGVN); 4103 } 4104 4105 virtual bool IsDeletable() const OVERRIDE { 4106 return skip_check() && !FLAG_debug_code; 4107 } 4108 }; 4109 4110 4111 class HBoundsCheckBaseIndexInformation FINAL 4112 : public HTemplateInstruction<2> { 4113 public: 4114 explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) { 4115 DecompositionResult decomposition; 4116 if (check->index()->TryDecompose(&decomposition)) { 4117 SetOperandAt(0, decomposition.base()); 4118 SetOperandAt(1, check); 4119 } else { 4120 UNREACHABLE(); 4121 } 4122 } 4123 4124 HValue* base_index() const { return OperandAt(0); } 4125 HBoundsCheck* bounds_check() { return HBoundsCheck::cast(OperandAt(1)); } 4126 4127 DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation) 4128 4129 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4130 return representation(); 4131 } 4132 4133 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4134 4135 virtual int RedefinedOperandIndex() OVERRIDE { return 0; } 4136 virtual bool IsPurelyInformativeDefinition() OVERRIDE { return true; } 4137 }; 4138 4139 4140 class HBitwiseBinaryOperation : public HBinaryOperation { 4141 public: 4142 HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right, 4143 HType type = HType::TaggedNumber()) 4144 : HBinaryOperation(context, left, right, type) { 4145 SetFlag(kFlexibleRepresentation); 4146 SetFlag(kTruncatingToInt32); 4147 SetFlag(kAllowUndefinedAsNaN); 4148 SetAllSideEffects(); 4149 } 4150 4151 virtual void RepresentationChanged(Representation to) OVERRIDE { 4152 if (to.IsTagged() && 4153 (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) { 4154 SetAllSideEffects(); 4155 ClearFlag(kUseGVN); 4156 } else { 4157 ClearAllSideEffects(); 4158 SetFlag(kUseGVN); 4159 } 4160 if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion); 4161 } 4162 4163 virtual void UpdateRepresentation(Representation new_rep, 4164 HInferRepresentationPhase* h_infer, 4165 const char* reason) OVERRIDE { 4166 // We only generate either int32 or generic tagged bitwise operations. 4167 if (new_rep.IsDouble()) new_rep = Representation::Integer32(); 4168 HBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 4169 } 4170 4171 virtual Representation observed_input_representation(int index) OVERRIDE { 4172 Representation r = HBinaryOperation::observed_input_representation(index); 4173 if (r.IsDouble()) return Representation::Integer32(); 4174 return r; 4175 } 4176 4177 virtual void initialize_output_representation(Representation observed) { 4178 if (observed.IsDouble()) observed = Representation::Integer32(); 4179 HBinaryOperation::initialize_output_representation(observed); 4180 } 4181 4182 DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation) 4183 4184 private: 4185 virtual bool IsDeletable() const OVERRIDE { return true; } 4186 }; 4187 4188 4189 class HMathFloorOfDiv FINAL : public HBinaryOperation { 4190 public: 4191 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HMathFloorOfDiv, 4192 HValue*, 4193 HValue*); 4194 4195 DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv) 4196 4197 protected: 4198 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4199 4200 private: 4201 HMathFloorOfDiv(HValue* context, HValue* left, HValue* right) 4202 : HBinaryOperation(context, left, right) { 4203 set_representation(Representation::Integer32()); 4204 SetFlag(kUseGVN); 4205 SetFlag(kCanOverflow); 4206 SetFlag(kCanBeDivByZero); 4207 SetFlag(kLeftCanBeMinInt); 4208 SetFlag(kLeftCanBeNegative); 4209 SetFlag(kLeftCanBePositive); 4210 SetFlag(kAllowUndefinedAsNaN); 4211 } 4212 4213 virtual Range* InferRange(Zone* zone) OVERRIDE; 4214 4215 virtual bool IsDeletable() const OVERRIDE { return true; } 4216 }; 4217 4218 4219 class HArithmeticBinaryOperation : public HBinaryOperation { 4220 public: 4221 HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right) 4222 : HBinaryOperation(context, left, right, HType::TaggedNumber()) { 4223 SetAllSideEffects(); 4224 SetFlag(kFlexibleRepresentation); 4225 SetFlag(kAllowUndefinedAsNaN); 4226 } 4227 4228 virtual void RepresentationChanged(Representation to) OVERRIDE { 4229 if (to.IsTagged() && 4230 (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) { 4231 SetAllSideEffects(); 4232 ClearFlag(kUseGVN); 4233 } else { 4234 ClearAllSideEffects(); 4235 SetFlag(kUseGVN); 4236 } 4237 if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion); 4238 } 4239 4240 DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation) 4241 4242 private: 4243 virtual bool IsDeletable() const OVERRIDE { return true; } 4244 }; 4245 4246 4247 class HCompareGeneric FINAL : public HBinaryOperation { 4248 public: 4249 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCompareGeneric, HValue*, 4250 HValue*, Token::Value); 4251 4252 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4253 return index == 0 4254 ? Representation::Tagged() 4255 : representation(); 4256 } 4257 4258 Token::Value token() const { return token_; } 4259 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4260 4261 DECLARE_CONCRETE_INSTRUCTION(CompareGeneric) 4262 4263 private: 4264 HCompareGeneric(HValue* context, 4265 HValue* left, 4266 HValue* right, 4267 Token::Value token) 4268 : HBinaryOperation(context, left, right, HType::Boolean()), 4269 token_(token) { 4270 DCHECK(Token::IsCompareOp(token)); 4271 set_representation(Representation::Tagged()); 4272 SetAllSideEffects(); 4273 } 4274 4275 Token::Value token_; 4276 }; 4277 4278 4279 class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> { 4280 public: 4281 DECLARE_INSTRUCTION_FACTORY_P3(HCompareNumericAndBranch, 4282 HValue*, HValue*, Token::Value); 4283 DECLARE_INSTRUCTION_FACTORY_P5(HCompareNumericAndBranch, 4284 HValue*, HValue*, Token::Value, 4285 HBasicBlock*, HBasicBlock*); 4286 4287 HValue* left() const { return OperandAt(0); } 4288 HValue* right() const { return OperandAt(1); } 4289 Token::Value token() const { return token_; } 4290 4291 void set_observed_input_representation(Representation left, 4292 Representation right) { 4293 observed_input_representation_[0] = left; 4294 observed_input_representation_[1] = right; 4295 } 4296 4297 virtual void InferRepresentation( 4298 HInferRepresentationPhase* h_infer) OVERRIDE; 4299 4300 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4301 return representation(); 4302 } 4303 virtual Representation observed_input_representation(int index) OVERRIDE { 4304 return observed_input_representation_[index]; 4305 } 4306 4307 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4308 4309 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4310 4311 void SetOperandPositions(Zone* zone, 4312 HSourcePosition left_pos, 4313 HSourcePosition right_pos) { 4314 set_operand_position(zone, 0, left_pos); 4315 set_operand_position(zone, 1, right_pos); 4316 } 4317 4318 DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch) 4319 4320 private: 4321 HCompareNumericAndBranch(HValue* left, 4322 HValue* right, 4323 Token::Value token, 4324 HBasicBlock* true_target = NULL, 4325 HBasicBlock* false_target = NULL) 4326 : token_(token) { 4327 SetFlag(kFlexibleRepresentation); 4328 DCHECK(Token::IsCompareOp(token)); 4329 SetOperandAt(0, left); 4330 SetOperandAt(1, right); 4331 SetSuccessorAt(0, true_target); 4332 SetSuccessorAt(1, false_target); 4333 } 4334 4335 Representation observed_input_representation_[2]; 4336 Token::Value token_; 4337 }; 4338 4339 4340 class HCompareHoleAndBranch FINAL : public HUnaryControlInstruction { 4341 public: 4342 DECLARE_INSTRUCTION_FACTORY_P1(HCompareHoleAndBranch, HValue*); 4343 DECLARE_INSTRUCTION_FACTORY_P3(HCompareHoleAndBranch, HValue*, 4344 HBasicBlock*, HBasicBlock*); 4345 4346 virtual void InferRepresentation( 4347 HInferRepresentationPhase* h_infer) OVERRIDE; 4348 4349 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4350 return representation(); 4351 } 4352 4353 DECLARE_CONCRETE_INSTRUCTION(CompareHoleAndBranch) 4354 4355 private: 4356 HCompareHoleAndBranch(HValue* value, 4357 HBasicBlock* true_target = NULL, 4358 HBasicBlock* false_target = NULL) 4359 : HUnaryControlInstruction(value, true_target, false_target) { 4360 SetFlag(kFlexibleRepresentation); 4361 SetFlag(kAllowUndefinedAsNaN); 4362 } 4363 }; 4364 4365 4366 class HCompareMinusZeroAndBranch FINAL : public HUnaryControlInstruction { 4367 public: 4368 DECLARE_INSTRUCTION_FACTORY_P1(HCompareMinusZeroAndBranch, HValue*); 4369 4370 virtual void InferRepresentation( 4371 HInferRepresentationPhase* h_infer) OVERRIDE; 4372 4373 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4374 return representation(); 4375 } 4376 4377 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4378 4379 DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch) 4380 4381 private: 4382 explicit HCompareMinusZeroAndBranch(HValue* value) 4383 : HUnaryControlInstruction(value, NULL, NULL) { 4384 } 4385 }; 4386 4387 4388 class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> { 4389 public: 4390 DECLARE_INSTRUCTION_FACTORY_P2(HCompareObjectEqAndBranch, HValue*, HValue*); 4391 DECLARE_INSTRUCTION_FACTORY_P4(HCompareObjectEqAndBranch, HValue*, HValue*, 4392 HBasicBlock*, HBasicBlock*); 4393 4394 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4395 4396 static const int kNoKnownSuccessorIndex = -1; 4397 int known_successor_index() const { return known_successor_index_; } 4398 void set_known_successor_index(int known_successor_index) { 4399 known_successor_index_ = known_successor_index; 4400 } 4401 4402 HValue* left() const { return OperandAt(0); } 4403 HValue* right() const { return OperandAt(1); } 4404 4405 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4406 4407 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4408 return Representation::Tagged(); 4409 } 4410 4411 virtual Representation observed_input_representation(int index) OVERRIDE { 4412 return Representation::Tagged(); 4413 } 4414 4415 DECLARE_CONCRETE_INSTRUCTION(CompareObjectEqAndBranch) 4416 4417 private: 4418 HCompareObjectEqAndBranch(HValue* left, 4419 HValue* right, 4420 HBasicBlock* true_target = NULL, 4421 HBasicBlock* false_target = NULL) 4422 : known_successor_index_(kNoKnownSuccessorIndex) { 4423 SetOperandAt(0, left); 4424 SetOperandAt(1, right); 4425 SetSuccessorAt(0, true_target); 4426 SetSuccessorAt(1, false_target); 4427 } 4428 4429 int known_successor_index_; 4430 }; 4431 4432 4433 class HIsObjectAndBranch FINAL : public HUnaryControlInstruction { 4434 public: 4435 DECLARE_INSTRUCTION_FACTORY_P1(HIsObjectAndBranch, HValue*); 4436 DECLARE_INSTRUCTION_FACTORY_P3(HIsObjectAndBranch, HValue*, 4437 HBasicBlock*, HBasicBlock*); 4438 4439 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4440 return Representation::Tagged(); 4441 } 4442 4443 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4444 4445 DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch) 4446 4447 private: 4448 HIsObjectAndBranch(HValue* value, 4449 HBasicBlock* true_target = NULL, 4450 HBasicBlock* false_target = NULL) 4451 : HUnaryControlInstruction(value, true_target, false_target) {} 4452 }; 4453 4454 4455 class HIsStringAndBranch FINAL : public HUnaryControlInstruction { 4456 public: 4457 DECLARE_INSTRUCTION_FACTORY_P1(HIsStringAndBranch, HValue*); 4458 DECLARE_INSTRUCTION_FACTORY_P3(HIsStringAndBranch, HValue*, 4459 HBasicBlock*, HBasicBlock*); 4460 4461 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4462 return Representation::Tagged(); 4463 } 4464 4465 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4466 4467 static const int kNoKnownSuccessorIndex = -1; 4468 int known_successor_index() const { return known_successor_index_; } 4469 void set_known_successor_index(int known_successor_index) { 4470 known_successor_index_ = known_successor_index; 4471 } 4472 4473 DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch) 4474 4475 protected: 4476 virtual int RedefinedOperandIndex() { return 0; } 4477 4478 private: 4479 HIsStringAndBranch(HValue* value, 4480 HBasicBlock* true_target = NULL, 4481 HBasicBlock* false_target = NULL) 4482 : HUnaryControlInstruction(value, true_target, false_target), 4483 known_successor_index_(kNoKnownSuccessorIndex) { } 4484 4485 int known_successor_index_; 4486 }; 4487 4488 4489 class HIsSmiAndBranch FINAL : public HUnaryControlInstruction { 4490 public: 4491 DECLARE_INSTRUCTION_FACTORY_P1(HIsSmiAndBranch, HValue*); 4492 DECLARE_INSTRUCTION_FACTORY_P3(HIsSmiAndBranch, HValue*, 4493 HBasicBlock*, HBasicBlock*); 4494 4495 DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch) 4496 4497 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4498 return Representation::Tagged(); 4499 } 4500 4501 protected: 4502 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4503 virtual int RedefinedOperandIndex() { return 0; } 4504 4505 private: 4506 HIsSmiAndBranch(HValue* value, 4507 HBasicBlock* true_target = NULL, 4508 HBasicBlock* false_target = NULL) 4509 : HUnaryControlInstruction(value, true_target, false_target) { 4510 set_representation(Representation::Tagged()); 4511 } 4512 }; 4513 4514 4515 class HIsUndetectableAndBranch FINAL : public HUnaryControlInstruction { 4516 public: 4517 DECLARE_INSTRUCTION_FACTORY_P1(HIsUndetectableAndBranch, HValue*); 4518 DECLARE_INSTRUCTION_FACTORY_P3(HIsUndetectableAndBranch, HValue*, 4519 HBasicBlock*, HBasicBlock*); 4520 4521 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4522 return Representation::Tagged(); 4523 } 4524 4525 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4526 4527 DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch) 4528 4529 private: 4530 HIsUndetectableAndBranch(HValue* value, 4531 HBasicBlock* true_target = NULL, 4532 HBasicBlock* false_target = NULL) 4533 : HUnaryControlInstruction(value, true_target, false_target) {} 4534 }; 4535 4536 4537 class HStringCompareAndBranch : public HTemplateControlInstruction<2, 3> { 4538 public: 4539 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HStringCompareAndBranch, 4540 HValue*, 4541 HValue*, 4542 Token::Value); 4543 4544 HValue* context() { return OperandAt(0); } 4545 HValue* left() { return OperandAt(1); } 4546 HValue* right() { return OperandAt(2); } 4547 Token::Value token() const { return token_; } 4548 4549 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4550 4551 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4552 return Representation::Tagged(); 4553 } 4554 4555 Representation GetInputRepresentation() const { 4556 return Representation::Tagged(); 4557 } 4558 4559 DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch) 4560 4561 private: 4562 HStringCompareAndBranch(HValue* context, 4563 HValue* left, 4564 HValue* right, 4565 Token::Value token) 4566 : token_(token) { 4567 DCHECK(Token::IsCompareOp(token)); 4568 SetOperandAt(0, context); 4569 SetOperandAt(1, left); 4570 SetOperandAt(2, right); 4571 set_representation(Representation::Tagged()); 4572 SetChangesFlag(kNewSpacePromotion); 4573 } 4574 4575 Token::Value token_; 4576 }; 4577 4578 4579 class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> { 4580 public: 4581 DECLARE_INSTRUCTION_FACTORY_P0(HIsConstructCallAndBranch); 4582 4583 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4584 return Representation::None(); 4585 } 4586 4587 DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch) 4588 private: 4589 HIsConstructCallAndBranch() {} 4590 }; 4591 4592 4593 class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction { 4594 public: 4595 DECLARE_INSTRUCTION_FACTORY_P2( 4596 HHasInstanceTypeAndBranch, HValue*, InstanceType); 4597 DECLARE_INSTRUCTION_FACTORY_P3( 4598 HHasInstanceTypeAndBranch, HValue*, InstanceType, InstanceType); 4599 4600 InstanceType from() { return from_; } 4601 InstanceType to() { return to_; } 4602 4603 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4604 4605 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4606 return Representation::Tagged(); 4607 } 4608 4609 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4610 4611 DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch) 4612 4613 private: 4614 HHasInstanceTypeAndBranch(HValue* value, InstanceType type) 4615 : HUnaryControlInstruction(value, NULL, NULL), from_(type), to_(type) { } 4616 HHasInstanceTypeAndBranch(HValue* value, InstanceType from, InstanceType to) 4617 : HUnaryControlInstruction(value, NULL, NULL), from_(from), to_(to) { 4618 DCHECK(to == LAST_TYPE); // Others not implemented yet in backend. 4619 } 4620 4621 InstanceType from_; 4622 InstanceType to_; // Inclusive range, not all combinations work. 4623 }; 4624 4625 4626 class HHasCachedArrayIndexAndBranch FINAL : public HUnaryControlInstruction { 4627 public: 4628 DECLARE_INSTRUCTION_FACTORY_P1(HHasCachedArrayIndexAndBranch, HValue*); 4629 4630 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4631 return Representation::Tagged(); 4632 } 4633 4634 DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch) 4635 private: 4636 explicit HHasCachedArrayIndexAndBranch(HValue* value) 4637 : HUnaryControlInstruction(value, NULL, NULL) { } 4638 }; 4639 4640 4641 class HGetCachedArrayIndex FINAL : public HUnaryOperation { 4642 public: 4643 DECLARE_INSTRUCTION_FACTORY_P1(HGetCachedArrayIndex, HValue*); 4644 4645 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4646 return Representation::Tagged(); 4647 } 4648 4649 DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex) 4650 4651 protected: 4652 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4653 4654 private: 4655 explicit HGetCachedArrayIndex(HValue* value) : HUnaryOperation(value) { 4656 set_representation(Representation::Tagged()); 4657 SetFlag(kUseGVN); 4658 } 4659 4660 virtual bool IsDeletable() const OVERRIDE { return true; } 4661 }; 4662 4663 4664 class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction { 4665 public: 4666 DECLARE_INSTRUCTION_FACTORY_P2(HClassOfTestAndBranch, HValue*, 4667 Handle<String>); 4668 4669 DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch) 4670 4671 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4672 return Representation::Tagged(); 4673 } 4674 4675 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4676 4677 Handle<String> class_name() const { return class_name_; } 4678 4679 private: 4680 HClassOfTestAndBranch(HValue* value, Handle<String> class_name) 4681 : HUnaryControlInstruction(value, NULL, NULL), 4682 class_name_(class_name) { } 4683 4684 Handle<String> class_name_; 4685 }; 4686 4687 4688 class HTypeofIsAndBranch FINAL : public HUnaryControlInstruction { 4689 public: 4690 DECLARE_INSTRUCTION_FACTORY_P2(HTypeofIsAndBranch, HValue*, Handle<String>); 4691 4692 Handle<String> type_literal() const { return type_literal_.handle(); } 4693 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4694 4695 DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch) 4696 4697 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4698 return Representation::None(); 4699 } 4700 4701 virtual bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE; 4702 4703 virtual void FinalizeUniqueness() OVERRIDE { 4704 type_literal_ = Unique<String>(type_literal_.handle()); 4705 } 4706 4707 private: 4708 HTypeofIsAndBranch(HValue* value, Handle<String> type_literal) 4709 : HUnaryControlInstruction(value, NULL, NULL), 4710 type_literal_(Unique<String>::CreateUninitialized(type_literal)) { } 4711 4712 Unique<String> type_literal_; 4713 }; 4714 4715 4716 class HInstanceOf FINAL : public HBinaryOperation { 4717 public: 4718 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOf, HValue*, HValue*); 4719 4720 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4721 return Representation::Tagged(); 4722 } 4723 4724 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 4725 4726 DECLARE_CONCRETE_INSTRUCTION(InstanceOf) 4727 4728 private: 4729 HInstanceOf(HValue* context, HValue* left, HValue* right) 4730 : HBinaryOperation(context, left, right, HType::Boolean()) { 4731 set_representation(Representation::Tagged()); 4732 SetAllSideEffects(); 4733 } 4734 }; 4735 4736 4737 class HInstanceOfKnownGlobal FINAL : public HTemplateInstruction<2> { 4738 public: 4739 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOfKnownGlobal, 4740 HValue*, 4741 Handle<JSFunction>); 4742 4743 HValue* context() { return OperandAt(0); } 4744 HValue* left() { return OperandAt(1); } 4745 Handle<JSFunction> function() { return function_; } 4746 4747 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4748 return Representation::Tagged(); 4749 } 4750 4751 DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal) 4752 4753 private: 4754 HInstanceOfKnownGlobal(HValue* context, 4755 HValue* left, 4756 Handle<JSFunction> right) 4757 : HTemplateInstruction<2>(HType::Boolean()), function_(right) { 4758 SetOperandAt(0, context); 4759 SetOperandAt(1, left); 4760 set_representation(Representation::Tagged()); 4761 SetAllSideEffects(); 4762 } 4763 4764 Handle<JSFunction> function_; 4765 }; 4766 4767 4768 class HPower FINAL : public HTemplateInstruction<2> { 4769 public: 4770 static HInstruction* New(Zone* zone, 4771 HValue* context, 4772 HValue* left, 4773 HValue* right); 4774 4775 HValue* left() { return OperandAt(0); } 4776 HValue* right() const { return OperandAt(1); } 4777 4778 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 4779 return index == 0 4780 ? Representation::Double() 4781 : Representation::None(); 4782 } 4783 virtual Representation observed_input_representation(int index) OVERRIDE { 4784 return RequiredInputRepresentation(index); 4785 } 4786 4787 DECLARE_CONCRETE_INSTRUCTION(Power) 4788 4789 protected: 4790 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4791 4792 private: 4793 HPower(HValue* left, HValue* right) { 4794 SetOperandAt(0, left); 4795 SetOperandAt(1, right); 4796 set_representation(Representation::Double()); 4797 SetFlag(kUseGVN); 4798 SetChangesFlag(kNewSpacePromotion); 4799 } 4800 4801 virtual bool IsDeletable() const OVERRIDE { 4802 return !right()->representation().IsTagged(); 4803 } 4804 }; 4805 4806 4807 class HAdd FINAL : public HArithmeticBinaryOperation { 4808 public: 4809 static HInstruction* New(Zone* zone, 4810 HValue* context, 4811 HValue* left, 4812 HValue* right); 4813 4814 // Add is only commutative if two integer values are added and not if two 4815 // tagged values are added (because it might be a String concatenation). 4816 // We also do not commute (pointer + offset). 4817 virtual bool IsCommutative() const OVERRIDE { 4818 return !representation().IsTagged() && !representation().IsExternal(); 4819 } 4820 4821 virtual HValue* Canonicalize() OVERRIDE; 4822 4823 virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE { 4824 if (left()->IsInteger32Constant()) { 4825 decomposition->Apply(right(), left()->GetInteger32Constant()); 4826 return true; 4827 } else if (right()->IsInteger32Constant()) { 4828 decomposition->Apply(left(), right()->GetInteger32Constant()); 4829 return true; 4830 } else { 4831 return false; 4832 } 4833 } 4834 4835 virtual void RepresentationChanged(Representation to) OVERRIDE { 4836 if (to.IsTagged() && 4837 (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved() || 4838 left()->ToStringCanBeObserved() || right()->ToStringCanBeObserved())) { 4839 SetAllSideEffects(); 4840 ClearFlag(kUseGVN); 4841 } else { 4842 ClearAllSideEffects(); 4843 SetFlag(kUseGVN); 4844 } 4845 if (to.IsTagged()) { 4846 SetChangesFlag(kNewSpacePromotion); 4847 ClearFlag(kAllowUndefinedAsNaN); 4848 } 4849 } 4850 4851 virtual Representation RepresentationFromInputs() OVERRIDE; 4852 4853 virtual Representation RequiredInputRepresentation(int index) OVERRIDE; 4854 4855 DECLARE_CONCRETE_INSTRUCTION(Add) 4856 4857 protected: 4858 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4859 4860 virtual Range* InferRange(Zone* zone) OVERRIDE; 4861 4862 private: 4863 HAdd(HValue* context, HValue* left, HValue* right) 4864 : HArithmeticBinaryOperation(context, left, right) { 4865 SetFlag(kCanOverflow); 4866 } 4867 }; 4868 4869 4870 class HSub FINAL : public HArithmeticBinaryOperation { 4871 public: 4872 static HInstruction* New(Zone* zone, 4873 HValue* context, 4874 HValue* left, 4875 HValue* right); 4876 4877 virtual HValue* Canonicalize() OVERRIDE; 4878 4879 virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE { 4880 if (right()->IsInteger32Constant()) { 4881 decomposition->Apply(left(), -right()->GetInteger32Constant()); 4882 return true; 4883 } else { 4884 return false; 4885 } 4886 } 4887 4888 DECLARE_CONCRETE_INSTRUCTION(Sub) 4889 4890 protected: 4891 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4892 4893 virtual Range* InferRange(Zone* zone) OVERRIDE; 4894 4895 private: 4896 HSub(HValue* context, HValue* left, HValue* right) 4897 : HArithmeticBinaryOperation(context, left, right) { 4898 SetFlag(kCanOverflow); 4899 } 4900 }; 4901 4902 4903 class HMul FINAL : public HArithmeticBinaryOperation { 4904 public: 4905 static HInstruction* New(Zone* zone, 4906 HValue* context, 4907 HValue* left, 4908 HValue* right); 4909 4910 static HInstruction* NewImul(Zone* zone, 4911 HValue* context, 4912 HValue* left, 4913 HValue* right) { 4914 HInstruction* instr = HMul::New(zone, context, left, right); 4915 if (!instr->IsMul()) return instr; 4916 HMul* mul = HMul::cast(instr); 4917 // TODO(mstarzinger): Prevent bailout on minus zero for imul. 4918 mul->AssumeRepresentation(Representation::Integer32()); 4919 mul->ClearFlag(HValue::kCanOverflow); 4920 return mul; 4921 } 4922 4923 virtual HValue* Canonicalize() OVERRIDE; 4924 4925 // Only commutative if it is certain that not two objects are multiplicated. 4926 virtual bool IsCommutative() const OVERRIDE { 4927 return !representation().IsTagged(); 4928 } 4929 4930 virtual void UpdateRepresentation(Representation new_rep, 4931 HInferRepresentationPhase* h_infer, 4932 const char* reason) OVERRIDE { 4933 HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 4934 } 4935 4936 bool MulMinusOne(); 4937 4938 DECLARE_CONCRETE_INSTRUCTION(Mul) 4939 4940 protected: 4941 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4942 4943 virtual Range* InferRange(Zone* zone) OVERRIDE; 4944 4945 private: 4946 HMul(HValue* context, HValue* left, HValue* right) 4947 : HArithmeticBinaryOperation(context, left, right) { 4948 SetFlag(kCanOverflow); 4949 } 4950 }; 4951 4952 4953 class HMod FINAL : public HArithmeticBinaryOperation { 4954 public: 4955 static HInstruction* New(Zone* zone, 4956 HValue* context, 4957 HValue* left, 4958 HValue* right); 4959 4960 virtual HValue* Canonicalize() OVERRIDE; 4961 4962 virtual void UpdateRepresentation(Representation new_rep, 4963 HInferRepresentationPhase* h_infer, 4964 const char* reason) OVERRIDE { 4965 if (new_rep.IsSmi()) new_rep = Representation::Integer32(); 4966 HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 4967 } 4968 4969 DECLARE_CONCRETE_INSTRUCTION(Mod) 4970 4971 protected: 4972 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 4973 4974 virtual Range* InferRange(Zone* zone) OVERRIDE; 4975 4976 private: 4977 HMod(HValue* context, 4978 HValue* left, 4979 HValue* right) : HArithmeticBinaryOperation(context, left, right) { 4980 SetFlag(kCanBeDivByZero); 4981 SetFlag(kCanOverflow); 4982 SetFlag(kLeftCanBeNegative); 4983 } 4984 }; 4985 4986 4987 class HDiv FINAL : public HArithmeticBinaryOperation { 4988 public: 4989 static HInstruction* New(Zone* zone, 4990 HValue* context, 4991 HValue* left, 4992 HValue* right); 4993 4994 virtual HValue* Canonicalize() OVERRIDE; 4995 4996 virtual void UpdateRepresentation(Representation new_rep, 4997 HInferRepresentationPhase* h_infer, 4998 const char* reason) OVERRIDE { 4999 if (new_rep.IsSmi()) new_rep = Representation::Integer32(); 5000 HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 5001 } 5002 5003 DECLARE_CONCRETE_INSTRUCTION(Div) 5004 5005 protected: 5006 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 5007 5008 virtual Range* InferRange(Zone* zone) OVERRIDE; 5009 5010 private: 5011 HDiv(HValue* context, HValue* left, HValue* right) 5012 : HArithmeticBinaryOperation(context, left, right) { 5013 SetFlag(kCanBeDivByZero); 5014 SetFlag(kCanOverflow); 5015 } 5016 }; 5017 5018 5019 class HMathMinMax FINAL : public HArithmeticBinaryOperation { 5020 public: 5021 enum Operation { kMathMin, kMathMax }; 5022 5023 static HInstruction* New(Zone* zone, 5024 HValue* context, 5025 HValue* left, 5026 HValue* right, 5027 Operation op); 5028 5029 virtual Representation observed_input_representation(int index) OVERRIDE { 5030 return RequiredInputRepresentation(index); 5031 } 5032 5033 virtual void InferRepresentation( 5034 HInferRepresentationPhase* h_infer) OVERRIDE; 5035 5036 virtual Representation RepresentationFromInputs() OVERRIDE { 5037 Representation left_rep = left()->representation(); 5038 Representation right_rep = right()->representation(); 5039 Representation result = Representation::Smi(); 5040 result = result.generalize(left_rep); 5041 result = result.generalize(right_rep); 5042 if (result.IsTagged()) return Representation::Double(); 5043 return result; 5044 } 5045 5046 virtual bool IsCommutative() const OVERRIDE { return true; } 5047 5048 Operation operation() { return operation_; } 5049 5050 DECLARE_CONCRETE_INSTRUCTION(MathMinMax) 5051 5052 protected: 5053 virtual bool DataEquals(HValue* other) OVERRIDE { 5054 return other->IsMathMinMax() && 5055 HMathMinMax::cast(other)->operation_ == operation_; 5056 } 5057 5058 virtual Range* InferRange(Zone* zone) OVERRIDE; 5059 5060 private: 5061 HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op) 5062 : HArithmeticBinaryOperation(context, left, right), 5063 operation_(op) { } 5064 5065 Operation operation_; 5066 }; 5067 5068 5069 class HBitwise FINAL : public HBitwiseBinaryOperation { 5070 public: 5071 static HInstruction* New(Zone* zone, 5072 HValue* context, 5073 Token::Value op, 5074 HValue* left, 5075 HValue* right); 5076 5077 Token::Value op() const { return op_; } 5078 5079 virtual bool IsCommutative() const OVERRIDE { return true; } 5080 5081 virtual HValue* Canonicalize() OVERRIDE; 5082 5083 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5084 5085 DECLARE_CONCRETE_INSTRUCTION(Bitwise) 5086 5087 protected: 5088 virtual bool DataEquals(HValue* other) OVERRIDE { 5089 return op() == HBitwise::cast(other)->op(); 5090 } 5091 5092 virtual Range* InferRange(Zone* zone) OVERRIDE; 5093 5094 private: 5095 HBitwise(HValue* context, 5096 Token::Value op, 5097 HValue* left, 5098 HValue* right) 5099 : HBitwiseBinaryOperation(context, left, right), 5100 op_(op) { 5101 DCHECK(op == Token::BIT_AND || op == Token::BIT_OR || op == Token::BIT_XOR); 5102 // BIT_AND with a smi-range positive value will always unset the 5103 // entire sign-extension of the smi-sign. 5104 if (op == Token::BIT_AND && 5105 ((left->IsConstant() && 5106 left->representation().IsSmi() && 5107 HConstant::cast(left)->Integer32Value() >= 0) || 5108 (right->IsConstant() && 5109 right->representation().IsSmi() && 5110 HConstant::cast(right)->Integer32Value() >= 0))) { 5111 SetFlag(kTruncatingToSmi); 5112 SetFlag(kTruncatingToInt32); 5113 // BIT_OR with a smi-range negative value will always set the entire 5114 // sign-extension of the smi-sign. 5115 } else if (op == Token::BIT_OR && 5116 ((left->IsConstant() && 5117 left->representation().IsSmi() && 5118 HConstant::cast(left)->Integer32Value() < 0) || 5119 (right->IsConstant() && 5120 right->representation().IsSmi() && 5121 HConstant::cast(right)->Integer32Value() < 0))) { 5122 SetFlag(kTruncatingToSmi); 5123 SetFlag(kTruncatingToInt32); 5124 } 5125 } 5126 5127 Token::Value op_; 5128 }; 5129 5130 5131 class HShl FINAL : public HBitwiseBinaryOperation { 5132 public: 5133 static HInstruction* New(Zone* zone, 5134 HValue* context, 5135 HValue* left, 5136 HValue* right); 5137 5138 virtual Range* InferRange(Zone* zone) OVERRIDE; 5139 5140 virtual void UpdateRepresentation(Representation new_rep, 5141 HInferRepresentationPhase* h_infer, 5142 const char* reason) OVERRIDE { 5143 if (new_rep.IsSmi() && 5144 !(right()->IsInteger32Constant() && 5145 right()->GetInteger32Constant() >= 0)) { 5146 new_rep = Representation::Integer32(); 5147 } 5148 HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 5149 } 5150 5151 DECLARE_CONCRETE_INSTRUCTION(Shl) 5152 5153 protected: 5154 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 5155 5156 private: 5157 HShl(HValue* context, HValue* left, HValue* right) 5158 : HBitwiseBinaryOperation(context, left, right) { } 5159 }; 5160 5161 5162 class HShr FINAL : public HBitwiseBinaryOperation { 5163 public: 5164 static HInstruction* New(Zone* zone, 5165 HValue* context, 5166 HValue* left, 5167 HValue* right); 5168 5169 virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE { 5170 if (right()->IsInteger32Constant()) { 5171 if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) { 5172 // This is intended to look for HAdd and HSub, to handle compounds 5173 // like ((base + offset) >> scale) with one single decomposition. 5174 left()->TryDecompose(decomposition); 5175 return true; 5176 } 5177 } 5178 return false; 5179 } 5180 5181 virtual Range* InferRange(Zone* zone) OVERRIDE; 5182 5183 virtual void UpdateRepresentation(Representation new_rep, 5184 HInferRepresentationPhase* h_infer, 5185 const char* reason) OVERRIDE { 5186 if (new_rep.IsSmi()) new_rep = Representation::Integer32(); 5187 HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 5188 } 5189 5190 DECLARE_CONCRETE_INSTRUCTION(Shr) 5191 5192 protected: 5193 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 5194 5195 private: 5196 HShr(HValue* context, HValue* left, HValue* right) 5197 : HBitwiseBinaryOperation(context, left, right) { } 5198 }; 5199 5200 5201 class HSar FINAL : public HBitwiseBinaryOperation { 5202 public: 5203 static HInstruction* New(Zone* zone, 5204 HValue* context, 5205 HValue* left, 5206 HValue* right); 5207 5208 virtual bool TryDecompose(DecompositionResult* decomposition) OVERRIDE { 5209 if (right()->IsInteger32Constant()) { 5210 if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) { 5211 // This is intended to look for HAdd and HSub, to handle compounds 5212 // like ((base + offset) >> scale) with one single decomposition. 5213 left()->TryDecompose(decomposition); 5214 return true; 5215 } 5216 } 5217 return false; 5218 } 5219 5220 virtual Range* InferRange(Zone* zone) OVERRIDE; 5221 5222 virtual void UpdateRepresentation(Representation new_rep, 5223 HInferRepresentationPhase* h_infer, 5224 const char* reason) OVERRIDE { 5225 if (new_rep.IsSmi()) new_rep = Representation::Integer32(); 5226 HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 5227 } 5228 5229 DECLARE_CONCRETE_INSTRUCTION(Sar) 5230 5231 protected: 5232 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 5233 5234 private: 5235 HSar(HValue* context, HValue* left, HValue* right) 5236 : HBitwiseBinaryOperation(context, left, right) { } 5237 }; 5238 5239 5240 class HRor FINAL : public HBitwiseBinaryOperation { 5241 public: 5242 static HInstruction* New(Zone* zone, 5243 HValue* context, 5244 HValue* left, 5245 HValue* right) { 5246 return new(zone) HRor(context, left, right); 5247 } 5248 5249 virtual void UpdateRepresentation(Representation new_rep, 5250 HInferRepresentationPhase* h_infer, 5251 const char* reason) OVERRIDE { 5252 if (new_rep.IsSmi()) new_rep = Representation::Integer32(); 5253 HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason); 5254 } 5255 5256 DECLARE_CONCRETE_INSTRUCTION(Ror) 5257 5258 protected: 5259 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 5260 5261 private: 5262 HRor(HValue* context, HValue* left, HValue* right) 5263 : HBitwiseBinaryOperation(context, left, right) { 5264 ChangeRepresentation(Representation::Integer32()); 5265 } 5266 }; 5267 5268 5269 class HOsrEntry FINAL : public HTemplateInstruction<0> { 5270 public: 5271 DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId); 5272 5273 BailoutId ast_id() const { return ast_id_; } 5274 5275 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5276 return Representation::None(); 5277 } 5278 5279 DECLARE_CONCRETE_INSTRUCTION(OsrEntry) 5280 5281 private: 5282 explicit HOsrEntry(BailoutId ast_id) : ast_id_(ast_id) { 5283 SetChangesFlag(kOsrEntries); 5284 SetChangesFlag(kNewSpacePromotion); 5285 } 5286 5287 BailoutId ast_id_; 5288 }; 5289 5290 5291 class HParameter FINAL : public HTemplateInstruction<0> { 5292 public: 5293 enum ParameterKind { 5294 STACK_PARAMETER, 5295 REGISTER_PARAMETER 5296 }; 5297 5298 DECLARE_INSTRUCTION_FACTORY_P1(HParameter, unsigned); 5299 DECLARE_INSTRUCTION_FACTORY_P2(HParameter, unsigned, ParameterKind); 5300 DECLARE_INSTRUCTION_FACTORY_P3(HParameter, unsigned, ParameterKind, 5301 Representation); 5302 5303 unsigned index() const { return index_; } 5304 ParameterKind kind() const { return kind_; } 5305 5306 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5307 5308 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5309 return Representation::None(); 5310 } 5311 5312 DECLARE_CONCRETE_INSTRUCTION(Parameter) 5313 5314 private: 5315 explicit HParameter(unsigned index, 5316 ParameterKind kind = STACK_PARAMETER) 5317 : index_(index), 5318 kind_(kind) { 5319 set_representation(Representation::Tagged()); 5320 } 5321 5322 explicit HParameter(unsigned index, 5323 ParameterKind kind, 5324 Representation r) 5325 : index_(index), 5326 kind_(kind) { 5327 set_representation(r); 5328 } 5329 5330 unsigned index_; 5331 ParameterKind kind_; 5332 }; 5333 5334 5335 class HCallStub FINAL : public HUnaryCall { 5336 public: 5337 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallStub, CodeStub::Major, int); 5338 CodeStub::Major major_key() { return major_key_; } 5339 5340 HValue* context() { return value(); } 5341 5342 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5343 5344 DECLARE_CONCRETE_INSTRUCTION(CallStub) 5345 5346 private: 5347 HCallStub(HValue* context, CodeStub::Major major_key, int argument_count) 5348 : HUnaryCall(context, argument_count), 5349 major_key_(major_key) { 5350 } 5351 5352 CodeStub::Major major_key_; 5353 }; 5354 5355 5356 class HTailCallThroughMegamorphicCache FINAL : public HTemplateInstruction<3> { 5357 public: 5358 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HTailCallThroughMegamorphicCache, 5359 HValue*, HValue*, Code::Flags); 5360 5361 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5362 return Representation::Tagged(); 5363 } 5364 5365 HValue* context() const { return OperandAt(0); } 5366 HValue* receiver() const { return OperandAt(1); } 5367 HValue* name() const { return OperandAt(2); } 5368 Code::Flags flags() const { return flags_; } 5369 5370 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5371 5372 DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache) 5373 5374 private: 5375 HTailCallThroughMegamorphicCache(HValue* context, HValue* receiver, 5376 HValue* name, Code::Flags flags) 5377 : flags_(flags) { 5378 SetOperandAt(0, context); 5379 SetOperandAt(1, receiver); 5380 SetOperandAt(2, name); 5381 } 5382 5383 Code::Flags flags_; 5384 }; 5385 5386 5387 class HUnknownOSRValue FINAL : public HTemplateInstruction<0> { 5388 public: 5389 DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int); 5390 5391 virtual OStream& PrintDataTo(OStream& os) const; // NOLINT 5392 5393 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5394 return Representation::None(); 5395 } 5396 5397 void set_incoming_value(HPhi* value) { incoming_value_ = value; } 5398 HPhi* incoming_value() { return incoming_value_; } 5399 HEnvironment *environment() { return environment_; } 5400 int index() { return index_; } 5401 5402 virtual Representation KnownOptimalRepresentation() OVERRIDE { 5403 if (incoming_value_ == NULL) return Representation::None(); 5404 return incoming_value_->KnownOptimalRepresentation(); 5405 } 5406 5407 DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue) 5408 5409 private: 5410 HUnknownOSRValue(HEnvironment* environment, int index) 5411 : environment_(environment), 5412 index_(index), 5413 incoming_value_(NULL) { 5414 set_representation(Representation::Tagged()); 5415 } 5416 5417 HEnvironment* environment_; 5418 int index_; 5419 HPhi* incoming_value_; 5420 }; 5421 5422 5423 class HLoadGlobalCell FINAL : public HTemplateInstruction<0> { 5424 public: 5425 DECLARE_INSTRUCTION_FACTORY_P2(HLoadGlobalCell, Handle<Cell>, 5426 PropertyDetails); 5427 5428 Unique<Cell> cell() const { return cell_; } 5429 bool RequiresHoleCheck() const; 5430 5431 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5432 5433 virtual intptr_t Hashcode() OVERRIDE { 5434 return cell_.Hashcode(); 5435 } 5436 5437 virtual void FinalizeUniqueness() OVERRIDE { 5438 cell_ = Unique<Cell>(cell_.handle()); 5439 } 5440 5441 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5442 return Representation::None(); 5443 } 5444 5445 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalCell) 5446 5447 protected: 5448 virtual bool DataEquals(HValue* other) OVERRIDE { 5449 return cell_ == HLoadGlobalCell::cast(other)->cell_; 5450 } 5451 5452 private: 5453 HLoadGlobalCell(Handle<Cell> cell, PropertyDetails details) 5454 : cell_(Unique<Cell>::CreateUninitialized(cell)), details_(details) { 5455 set_representation(Representation::Tagged()); 5456 SetFlag(kUseGVN); 5457 SetDependsOnFlag(kGlobalVars); 5458 } 5459 5460 virtual bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); } 5461 5462 Unique<Cell> cell_; 5463 PropertyDetails details_; 5464 }; 5465 5466 5467 class HLoadGlobalGeneric FINAL : public HTemplateInstruction<2> { 5468 public: 5469 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadGlobalGeneric, HValue*, 5470 Handle<String>, bool); 5471 5472 HValue* context() { return OperandAt(0); } 5473 HValue* global_object() { return OperandAt(1); } 5474 Handle<String> name() const { return name_; } 5475 bool for_typeof() const { return for_typeof_; } 5476 int slot() const { 5477 DCHECK(FLAG_vector_ics && 5478 slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot); 5479 return slot_; 5480 } 5481 Handle<FixedArray> feedback_vector() const { return feedback_vector_; } 5482 void SetVectorAndSlot(Handle<FixedArray> vector, int slot) { 5483 DCHECK(FLAG_vector_ics); 5484 feedback_vector_ = vector; 5485 slot_ = slot; 5486 } 5487 5488 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5489 5490 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5491 return Representation::Tagged(); 5492 } 5493 5494 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric) 5495 5496 private: 5497 HLoadGlobalGeneric(HValue* context, HValue* global_object, 5498 Handle<String> name, bool for_typeof) 5499 : name_(name), for_typeof_(for_typeof), 5500 slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) { 5501 SetOperandAt(0, context); 5502 SetOperandAt(1, global_object); 5503 set_representation(Representation::Tagged()); 5504 SetAllSideEffects(); 5505 } 5506 5507 Handle<String> name_; 5508 bool for_typeof_; 5509 Handle<FixedArray> feedback_vector_; 5510 int slot_; 5511 }; 5512 5513 5514 class HAllocate FINAL : public HTemplateInstruction<2> { 5515 public: 5516 static bool CompatibleInstanceTypes(InstanceType type1, 5517 InstanceType type2) { 5518 return ComputeFlags(TENURED, type1) == ComputeFlags(TENURED, type2) && 5519 ComputeFlags(NOT_TENURED, type1) == ComputeFlags(NOT_TENURED, type2); 5520 } 5521 5522 static HAllocate* New(Zone* zone, 5523 HValue* context, 5524 HValue* size, 5525 HType type, 5526 PretenureFlag pretenure_flag, 5527 InstanceType instance_type, 5528 Handle<AllocationSite> allocation_site = 5529 Handle<AllocationSite>::null()) { 5530 return new(zone) HAllocate(context, size, type, pretenure_flag, 5531 instance_type, allocation_site); 5532 } 5533 5534 // Maximum instance size for which allocations will be inlined. 5535 static const int kMaxInlineSize = 64 * kPointerSize; 5536 5537 HValue* context() const { return OperandAt(0); } 5538 HValue* size() const { return OperandAt(1); } 5539 5540 bool has_size_upper_bound() { return size_upper_bound_ != NULL; } 5541 HConstant* size_upper_bound() { return size_upper_bound_; } 5542 void set_size_upper_bound(HConstant* value) { 5543 DCHECK(size_upper_bound_ == NULL); 5544 size_upper_bound_ = value; 5545 } 5546 5547 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5548 if (index == 0) { 5549 return Representation::Tagged(); 5550 } else { 5551 return Representation::Integer32(); 5552 } 5553 } 5554 5555 virtual Handle<Map> GetMonomorphicJSObjectMap() OVERRIDE { 5556 return known_initial_map_; 5557 } 5558 5559 void set_known_initial_map(Handle<Map> known_initial_map) { 5560 known_initial_map_ = known_initial_map; 5561 } 5562 5563 bool IsNewSpaceAllocation() const { 5564 return (flags_ & ALLOCATE_IN_NEW_SPACE) != 0; 5565 } 5566 5567 bool IsOldDataSpaceAllocation() const { 5568 return (flags_ & ALLOCATE_IN_OLD_DATA_SPACE) != 0; 5569 } 5570 5571 bool IsOldPointerSpaceAllocation() const { 5572 return (flags_ & ALLOCATE_IN_OLD_POINTER_SPACE) != 0; 5573 } 5574 5575 bool MustAllocateDoubleAligned() const { 5576 return (flags_ & ALLOCATE_DOUBLE_ALIGNED) != 0; 5577 } 5578 5579 bool MustPrefillWithFiller() const { 5580 return (flags_ & PREFILL_WITH_FILLER) != 0; 5581 } 5582 5583 void MakePrefillWithFiller() { 5584 flags_ = static_cast<HAllocate::Flags>(flags_ | PREFILL_WITH_FILLER); 5585 } 5586 5587 bool MustClearNextMapWord() const { 5588 return (flags_ & CLEAR_NEXT_MAP_WORD) != 0; 5589 } 5590 5591 void MakeDoubleAligned() { 5592 flags_ = static_cast<HAllocate::Flags>(flags_ | ALLOCATE_DOUBLE_ALIGNED); 5593 } 5594 5595 virtual bool HandleSideEffectDominator(GVNFlag side_effect, 5596 HValue* dominator) OVERRIDE; 5597 5598 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5599 5600 DECLARE_CONCRETE_INSTRUCTION(Allocate) 5601 5602 private: 5603 enum Flags { 5604 ALLOCATE_IN_NEW_SPACE = 1 << 0, 5605 ALLOCATE_IN_OLD_DATA_SPACE = 1 << 1, 5606 ALLOCATE_IN_OLD_POINTER_SPACE = 1 << 2, 5607 ALLOCATE_DOUBLE_ALIGNED = 1 << 3, 5608 PREFILL_WITH_FILLER = 1 << 4, 5609 CLEAR_NEXT_MAP_WORD = 1 << 5 5610 }; 5611 5612 HAllocate(HValue* context, 5613 HValue* size, 5614 HType type, 5615 PretenureFlag pretenure_flag, 5616 InstanceType instance_type, 5617 Handle<AllocationSite> allocation_site = 5618 Handle<AllocationSite>::null()) 5619 : HTemplateInstruction<2>(type), 5620 flags_(ComputeFlags(pretenure_flag, instance_type)), 5621 dominating_allocate_(NULL), 5622 filler_free_space_size_(NULL), 5623 size_upper_bound_(NULL) { 5624 SetOperandAt(0, context); 5625 UpdateSize(size); 5626 set_representation(Representation::Tagged()); 5627 SetFlag(kTrackSideEffectDominators); 5628 SetChangesFlag(kNewSpacePromotion); 5629 SetDependsOnFlag(kNewSpacePromotion); 5630 5631 if (FLAG_trace_pretenuring) { 5632 PrintF("HAllocate with AllocationSite %p %s\n", 5633 allocation_site.is_null() 5634 ? static_cast<void*>(NULL) 5635 : static_cast<void*>(*allocation_site), 5636 pretenure_flag == TENURED ? "tenured" : "not tenured"); 5637 } 5638 } 5639 5640 static Flags ComputeFlags(PretenureFlag pretenure_flag, 5641 InstanceType instance_type) { 5642 Flags flags = pretenure_flag == TENURED 5643 ? (Heap::TargetSpaceId(instance_type) == OLD_POINTER_SPACE 5644 ? ALLOCATE_IN_OLD_POINTER_SPACE : ALLOCATE_IN_OLD_DATA_SPACE) 5645 : ALLOCATE_IN_NEW_SPACE; 5646 if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) { 5647 flags = static_cast<Flags>(flags | ALLOCATE_DOUBLE_ALIGNED); 5648 } 5649 // We have to fill the allocated object with one word fillers if we do 5650 // not use allocation folding since some allocations may depend on each 5651 // other, i.e., have a pointer to each other. A GC in between these 5652 // allocations may leave such objects behind in a not completely initialized 5653 // state. 5654 if (!FLAG_use_gvn || !FLAG_use_allocation_folding) { 5655 flags = static_cast<Flags>(flags | PREFILL_WITH_FILLER); 5656 } 5657 if (pretenure_flag == NOT_TENURED && 5658 AllocationSite::CanTrack(instance_type)) { 5659 flags = static_cast<Flags>(flags | CLEAR_NEXT_MAP_WORD); 5660 } 5661 return flags; 5662 } 5663 5664 void UpdateClearNextMapWord(bool clear_next_map_word) { 5665 flags_ = static_cast<Flags>(clear_next_map_word 5666 ? flags_ | CLEAR_NEXT_MAP_WORD 5667 : flags_ & ~CLEAR_NEXT_MAP_WORD); 5668 } 5669 5670 void UpdateSize(HValue* size) { 5671 SetOperandAt(1, size); 5672 if (size->IsInteger32Constant()) { 5673 size_upper_bound_ = HConstant::cast(size); 5674 } else { 5675 size_upper_bound_ = NULL; 5676 } 5677 } 5678 5679 HAllocate* GetFoldableDominator(HAllocate* dominator); 5680 5681 void UpdateFreeSpaceFiller(int32_t filler_size); 5682 5683 void CreateFreeSpaceFiller(int32_t filler_size); 5684 5685 bool IsFoldable(HAllocate* allocate) { 5686 return (IsNewSpaceAllocation() && allocate->IsNewSpaceAllocation()) || 5687 (IsOldDataSpaceAllocation() && allocate->IsOldDataSpaceAllocation()) || 5688 (IsOldPointerSpaceAllocation() && 5689 allocate->IsOldPointerSpaceAllocation()); 5690 } 5691 5692 void ClearNextMapWord(int offset); 5693 5694 Flags flags_; 5695 Handle<Map> known_initial_map_; 5696 HAllocate* dominating_allocate_; 5697 HStoreNamedField* filler_free_space_size_; 5698 HConstant* size_upper_bound_; 5699 }; 5700 5701 5702 class HStoreCodeEntry FINAL: public HTemplateInstruction<2> { 5703 public: 5704 static HStoreCodeEntry* New(Zone* zone, 5705 HValue* context, 5706 HValue* function, 5707 HValue* code) { 5708 return new(zone) HStoreCodeEntry(function, code); 5709 } 5710 5711 virtual Representation RequiredInputRepresentation(int index) { 5712 return Representation::Tagged(); 5713 } 5714 5715 HValue* function() { return OperandAt(0); } 5716 HValue* code_object() { return OperandAt(1); } 5717 5718 DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry) 5719 5720 private: 5721 HStoreCodeEntry(HValue* function, HValue* code) { 5722 SetOperandAt(0, function); 5723 SetOperandAt(1, code); 5724 } 5725 }; 5726 5727 5728 class HInnerAllocatedObject FINAL : public HTemplateInstruction<2> { 5729 public: 5730 static HInnerAllocatedObject* New(Zone* zone, 5731 HValue* context, 5732 HValue* value, 5733 HValue* offset, 5734 HType type) { 5735 return new(zone) HInnerAllocatedObject(value, offset, type); 5736 } 5737 5738 HValue* base_object() const { return OperandAt(0); } 5739 HValue* offset() const { return OperandAt(1); } 5740 5741 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5742 return index == 0 ? Representation::Tagged() : Representation::Integer32(); 5743 } 5744 5745 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5746 5747 DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject) 5748 5749 private: 5750 HInnerAllocatedObject(HValue* value, 5751 HValue* offset, 5752 HType type) : HTemplateInstruction<2>(type) { 5753 DCHECK(value->IsAllocate()); 5754 DCHECK(type.IsHeapObject()); 5755 SetOperandAt(0, value); 5756 SetOperandAt(1, offset); 5757 set_representation(Representation::Tagged()); 5758 } 5759 }; 5760 5761 5762 inline bool StoringValueNeedsWriteBarrier(HValue* value) { 5763 return !value->type().IsSmi() 5764 && !value->type().IsNull() 5765 && !value->type().IsBoolean() 5766 && !value->type().IsUndefined() 5767 && !(value->IsConstant() && HConstant::cast(value)->ImmortalImmovable()); 5768 } 5769 5770 5771 inline bool ReceiverObjectNeedsWriteBarrier(HValue* object, 5772 HValue* value, 5773 HValue* dominator) { 5774 while (object->IsInnerAllocatedObject()) { 5775 object = HInnerAllocatedObject::cast(object)->base_object(); 5776 } 5777 if (object->IsConstant() && HConstant::cast(object)->IsCell()) { 5778 return false; 5779 } 5780 if (object->IsConstant() && 5781 HConstant::cast(object)->HasExternalReferenceValue()) { 5782 // Stores to external references require no write barriers 5783 return false; 5784 } 5785 // We definitely need a write barrier unless the object is the allocation 5786 // dominator. 5787 if (object == dominator && object->IsAllocate()) { 5788 // Stores to new space allocations require no write barriers. 5789 if (HAllocate::cast(object)->IsNewSpaceAllocation()) { 5790 return false; 5791 } 5792 // Stores to old space allocations require no write barriers if the value is 5793 // a constant provably not in new space. 5794 if (value->IsConstant() && HConstant::cast(value)->NotInNewSpace()) { 5795 return false; 5796 } 5797 // Stores to old space allocations require no write barriers if the value is 5798 // an old space allocation. 5799 while (value->IsInnerAllocatedObject()) { 5800 value = HInnerAllocatedObject::cast(value)->base_object(); 5801 } 5802 if (value->IsAllocate() && 5803 !HAllocate::cast(value)->IsNewSpaceAllocation()) { 5804 return false; 5805 } 5806 } 5807 return true; 5808 } 5809 5810 5811 inline PointersToHereCheck PointersToHereCheckForObject(HValue* object, 5812 HValue* dominator) { 5813 while (object->IsInnerAllocatedObject()) { 5814 object = HInnerAllocatedObject::cast(object)->base_object(); 5815 } 5816 if (object == dominator && 5817 object->IsAllocate() && 5818 HAllocate::cast(object)->IsNewSpaceAllocation()) { 5819 return kPointersToHereAreAlwaysInteresting; 5820 } 5821 return kPointersToHereMaybeInteresting; 5822 } 5823 5824 5825 class HStoreGlobalCell FINAL : public HUnaryOperation { 5826 public: 5827 DECLARE_INSTRUCTION_FACTORY_P3(HStoreGlobalCell, HValue*, 5828 Handle<PropertyCell>, PropertyDetails); 5829 5830 Unique<PropertyCell> cell() const { return cell_; } 5831 bool RequiresHoleCheck() { return details_.IsConfigurable(); } 5832 bool NeedsWriteBarrier() { 5833 return StoringValueNeedsWriteBarrier(value()); 5834 } 5835 5836 virtual void FinalizeUniqueness() OVERRIDE { 5837 cell_ = Unique<PropertyCell>(cell_.handle()); 5838 } 5839 5840 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5841 return Representation::Tagged(); 5842 } 5843 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5844 5845 DECLARE_CONCRETE_INSTRUCTION(StoreGlobalCell) 5846 5847 private: 5848 HStoreGlobalCell(HValue* value, 5849 Handle<PropertyCell> cell, 5850 PropertyDetails details) 5851 : HUnaryOperation(value), 5852 cell_(Unique<PropertyCell>::CreateUninitialized(cell)), 5853 details_(details) { 5854 SetChangesFlag(kGlobalVars); 5855 } 5856 5857 Unique<PropertyCell> cell_; 5858 PropertyDetails details_; 5859 }; 5860 5861 5862 class HLoadContextSlot FINAL : public HUnaryOperation { 5863 public: 5864 enum Mode { 5865 // Perform a normal load of the context slot without checking its value. 5866 kNoCheck, 5867 // Load and check the value of the context slot. Deoptimize if it's the 5868 // hole value. This is used for checking for loading of uninitialized 5869 // harmony bindings where we deoptimize into full-codegen generated code 5870 // which will subsequently throw a reference error. 5871 kCheckDeoptimize, 5872 // Load and check the value of the context slot. Return undefined if it's 5873 // the hole value. This is used for non-harmony const assignments 5874 kCheckReturnUndefined 5875 }; 5876 5877 HLoadContextSlot(HValue* context, int slot_index, Mode mode) 5878 : HUnaryOperation(context), slot_index_(slot_index), mode_(mode) { 5879 set_representation(Representation::Tagged()); 5880 SetFlag(kUseGVN); 5881 SetDependsOnFlag(kContextSlots); 5882 } 5883 5884 int slot_index() const { return slot_index_; } 5885 Mode mode() const { return mode_; } 5886 5887 bool DeoptimizesOnHole() { 5888 return mode_ == kCheckDeoptimize; 5889 } 5890 5891 bool RequiresHoleCheck() const { 5892 return mode_ != kNoCheck; 5893 } 5894 5895 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5896 return Representation::Tagged(); 5897 } 5898 5899 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5900 5901 DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot) 5902 5903 protected: 5904 virtual bool DataEquals(HValue* other) OVERRIDE { 5905 HLoadContextSlot* b = HLoadContextSlot::cast(other); 5906 return (slot_index() == b->slot_index()); 5907 } 5908 5909 private: 5910 virtual bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); } 5911 5912 int slot_index_; 5913 Mode mode_; 5914 }; 5915 5916 5917 class HStoreContextSlot FINAL : public HTemplateInstruction<2> { 5918 public: 5919 enum Mode { 5920 // Perform a normal store to the context slot without checking its previous 5921 // value. 5922 kNoCheck, 5923 // Check the previous value of the context slot and deoptimize if it's the 5924 // hole value. This is used for checking for assignments to uninitialized 5925 // harmony bindings where we deoptimize into full-codegen generated code 5926 // which will subsequently throw a reference error. 5927 kCheckDeoptimize, 5928 // Check the previous value and ignore assignment if it isn't a hole value 5929 kCheckIgnoreAssignment 5930 }; 5931 5932 DECLARE_INSTRUCTION_FACTORY_P4(HStoreContextSlot, HValue*, int, 5933 Mode, HValue*); 5934 5935 HValue* context() const { return OperandAt(0); } 5936 HValue* value() const { return OperandAt(1); } 5937 int slot_index() const { return slot_index_; } 5938 Mode mode() const { return mode_; } 5939 5940 bool NeedsWriteBarrier() { 5941 return StoringValueNeedsWriteBarrier(value()); 5942 } 5943 5944 bool DeoptimizesOnHole() { 5945 return mode_ == kCheckDeoptimize; 5946 } 5947 5948 bool RequiresHoleCheck() { 5949 return mode_ != kNoCheck; 5950 } 5951 5952 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 5953 return Representation::Tagged(); 5954 } 5955 5956 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 5957 5958 DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot) 5959 5960 private: 5961 HStoreContextSlot(HValue* context, int slot_index, Mode mode, HValue* value) 5962 : slot_index_(slot_index), mode_(mode) { 5963 SetOperandAt(0, context); 5964 SetOperandAt(1, value); 5965 SetChangesFlag(kContextSlots); 5966 } 5967 5968 int slot_index_; 5969 Mode mode_; 5970 }; 5971 5972 5973 // Represents an access to a portion of an object, such as the map pointer, 5974 // array elements pointer, etc, but not accesses to array elements themselves. 5975 class HObjectAccess FINAL { 5976 public: 5977 inline bool IsInobject() const { 5978 return portion() != kBackingStore && portion() != kExternalMemory; 5979 } 5980 5981 inline bool IsExternalMemory() const { 5982 return portion() == kExternalMemory; 5983 } 5984 5985 inline bool IsStringLength() const { 5986 return portion() == kStringLengths; 5987 } 5988 5989 inline bool IsMap() const { 5990 return portion() == kMaps; 5991 } 5992 5993 inline int offset() const { 5994 return OffsetField::decode(value_); 5995 } 5996 5997 inline Representation representation() const { 5998 return Representation::FromKind(RepresentationField::decode(value_)); 5999 } 6000 6001 inline Handle<String> name() const { 6002 return name_; 6003 } 6004 6005 inline bool immutable() const { 6006 return ImmutableField::decode(value_); 6007 } 6008 6009 // Returns true if access is being made to an in-object property that 6010 // was already added to the object. 6011 inline bool existing_inobject_property() const { 6012 return ExistingInobjectPropertyField::decode(value_); 6013 } 6014 6015 inline HObjectAccess WithRepresentation(Representation representation) { 6016 return HObjectAccess(portion(), offset(), representation, name(), 6017 immutable(), existing_inobject_property()); 6018 } 6019 6020 static HObjectAccess ForHeapNumberValue() { 6021 return HObjectAccess( 6022 kDouble, HeapNumber::kValueOffset, Representation::Double()); 6023 } 6024 6025 static HObjectAccess ForHeapNumberValueLowestBits() { 6026 return HObjectAccess(kDouble, 6027 HeapNumber::kValueOffset, 6028 Representation::Integer32()); 6029 } 6030 6031 static HObjectAccess ForHeapNumberValueHighestBits() { 6032 return HObjectAccess(kDouble, 6033 HeapNumber::kValueOffset + kIntSize, 6034 Representation::Integer32()); 6035 } 6036 6037 static HObjectAccess ForElementsPointer() { 6038 return HObjectAccess(kElementsPointer, JSObject::kElementsOffset); 6039 } 6040 6041 static HObjectAccess ForLiteralsPointer() { 6042 return HObjectAccess(kInobject, JSFunction::kLiteralsOffset); 6043 } 6044 6045 static HObjectAccess ForNextFunctionLinkPointer() { 6046 return HObjectAccess(kInobject, JSFunction::kNextFunctionLinkOffset); 6047 } 6048 6049 static HObjectAccess ForArrayLength(ElementsKind elements_kind) { 6050 return HObjectAccess( 6051 kArrayLengths, 6052 JSArray::kLengthOffset, 6053 IsFastElementsKind(elements_kind) 6054 ? Representation::Smi() : Representation::Tagged()); 6055 } 6056 6057 static HObjectAccess ForAllocationSiteOffset(int offset); 6058 6059 static HObjectAccess ForAllocationSiteList() { 6060 return HObjectAccess(kExternalMemory, 0, Representation::Tagged(), 6061 Handle<String>::null(), false, false); 6062 } 6063 6064 static HObjectAccess ForFixedArrayLength() { 6065 return HObjectAccess( 6066 kArrayLengths, 6067 FixedArray::kLengthOffset, 6068 Representation::Smi()); 6069 } 6070 6071 static HObjectAccess ForStringHashField() { 6072 return HObjectAccess(kInobject, 6073 String::kHashFieldOffset, 6074 Representation::Integer32()); 6075 } 6076 6077 static HObjectAccess ForStringLength() { 6078 STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue); 6079 return HObjectAccess( 6080 kStringLengths, 6081 String::kLengthOffset, 6082 Representation::Smi()); 6083 } 6084 6085 static HObjectAccess ForConsStringFirst() { 6086 return HObjectAccess(kInobject, ConsString::kFirstOffset); 6087 } 6088 6089 static HObjectAccess ForConsStringSecond() { 6090 return HObjectAccess(kInobject, ConsString::kSecondOffset); 6091 } 6092 6093 static HObjectAccess ForPropertiesPointer() { 6094 return HObjectAccess(kInobject, JSObject::kPropertiesOffset); 6095 } 6096 6097 static HObjectAccess ForPrototypeOrInitialMap() { 6098 return HObjectAccess(kInobject, JSFunction::kPrototypeOrInitialMapOffset); 6099 } 6100 6101 static HObjectAccess ForSharedFunctionInfoPointer() { 6102 return HObjectAccess(kInobject, JSFunction::kSharedFunctionInfoOffset); 6103 } 6104 6105 static HObjectAccess ForCodeEntryPointer() { 6106 return HObjectAccess(kInobject, JSFunction::kCodeEntryOffset); 6107 } 6108 6109 static HObjectAccess ForCodeOffset() { 6110 return HObjectAccess(kInobject, SharedFunctionInfo::kCodeOffset); 6111 } 6112 6113 static HObjectAccess ForOptimizedCodeMap() { 6114 return HObjectAccess(kInobject, 6115 SharedFunctionInfo::kOptimizedCodeMapOffset); 6116 } 6117 6118 static HObjectAccess ForFunctionContextPointer() { 6119 return HObjectAccess(kInobject, JSFunction::kContextOffset); 6120 } 6121 6122 static HObjectAccess ForMap() { 6123 return HObjectAccess(kMaps, JSObject::kMapOffset); 6124 } 6125 6126 static HObjectAccess ForMapAsInteger32() { 6127 return HObjectAccess(kMaps, JSObject::kMapOffset, 6128 Representation::Integer32()); 6129 } 6130 6131 static HObjectAccess ForMapInObjectProperties() { 6132 return HObjectAccess(kInobject, 6133 Map::kInObjectPropertiesOffset, 6134 Representation::UInteger8()); 6135 } 6136 6137 static HObjectAccess ForMapInstanceType() { 6138 return HObjectAccess(kInobject, 6139 Map::kInstanceTypeOffset, 6140 Representation::UInteger8()); 6141 } 6142 6143 static HObjectAccess ForMapInstanceSize() { 6144 return HObjectAccess(kInobject, 6145 Map::kInstanceSizeOffset, 6146 Representation::UInteger8()); 6147 } 6148 6149 static HObjectAccess ForMapBitField() { 6150 return HObjectAccess(kInobject, 6151 Map::kBitFieldOffset, 6152 Representation::UInteger8()); 6153 } 6154 6155 static HObjectAccess ForMapBitField2() { 6156 return HObjectAccess(kInobject, 6157 Map::kBitField2Offset, 6158 Representation::UInteger8()); 6159 } 6160 6161 static HObjectAccess ForNameHashField() { 6162 return HObjectAccess(kInobject, 6163 Name::kHashFieldOffset, 6164 Representation::Integer32()); 6165 } 6166 6167 static HObjectAccess ForMapInstanceTypeAndBitField() { 6168 STATIC_ASSERT((Map::kInstanceTypeAndBitFieldOffset & 1) == 0); 6169 // Ensure the two fields share one 16-bit word, endian-independent. 6170 STATIC_ASSERT((Map::kBitFieldOffset & ~1) == 6171 (Map::kInstanceTypeOffset & ~1)); 6172 return HObjectAccess(kInobject, 6173 Map::kInstanceTypeAndBitFieldOffset, 6174 Representation::UInteger16()); 6175 } 6176 6177 static HObjectAccess ForPropertyCellValue() { 6178 return HObjectAccess(kInobject, PropertyCell::kValueOffset); 6179 } 6180 6181 static HObjectAccess ForCellValue() { 6182 return HObjectAccess(kInobject, Cell::kValueOffset); 6183 } 6184 6185 static HObjectAccess ForAllocationMementoSite() { 6186 return HObjectAccess(kInobject, AllocationMemento::kAllocationSiteOffset); 6187 } 6188 6189 static HObjectAccess ForCounter() { 6190 return HObjectAccess(kExternalMemory, 0, Representation::Integer32(), 6191 Handle<String>::null(), false, false); 6192 } 6193 6194 static HObjectAccess ForExternalUInteger8() { 6195 return HObjectAccess(kExternalMemory, 0, Representation::UInteger8(), 6196 Handle<String>::null(), false, false); 6197 } 6198 6199 // Create an access to an offset in a fixed array header. 6200 static HObjectAccess ForFixedArrayHeader(int offset); 6201 6202 // Create an access to an in-object property in a JSObject. 6203 // This kind of access must be used when the object |map| is known and 6204 // in-object properties are being accessed. Accesses of the in-object 6205 // properties can have different semantics depending on whether corresponding 6206 // property was added to the map or not. 6207 static HObjectAccess ForMapAndOffset(Handle<Map> map, int offset, 6208 Representation representation = Representation::Tagged()); 6209 6210 // Create an access to an in-object property in a JSObject. 6211 // This kind of access can be used for accessing object header fields or 6212 // in-object properties if the map of the object is not known. 6213 static HObjectAccess ForObservableJSObjectOffset(int offset, 6214 Representation representation = Representation::Tagged()) { 6215 return ForMapAndOffset(Handle<Map>::null(), offset, representation); 6216 } 6217 6218 // Create an access to an in-object property in a JSArray. 6219 static HObjectAccess ForJSArrayOffset(int offset); 6220 6221 static HObjectAccess ForContextSlot(int index); 6222 6223 // Create an access to the backing store of an object. 6224 static HObjectAccess ForBackingStoreOffset(int offset, 6225 Representation representation = Representation::Tagged()); 6226 6227 // Create an access to a resolved field (in-object or backing store). 6228 static HObjectAccess ForField(Handle<Map> map, int index, 6229 Representation representation, 6230 Handle<String> name); 6231 6232 // Create an access for the payload of a Cell or JSGlobalPropertyCell. 6233 static HObjectAccess ForCellPayload(Isolate* isolate); 6234 6235 static HObjectAccess ForJSTypedArrayLength() { 6236 return HObjectAccess::ForObservableJSObjectOffset( 6237 JSTypedArray::kLengthOffset); 6238 } 6239 6240 static HObjectAccess ForJSArrayBufferBackingStore() { 6241 return HObjectAccess::ForObservableJSObjectOffset( 6242 JSArrayBuffer::kBackingStoreOffset, Representation::External()); 6243 } 6244 6245 static HObjectAccess ForJSArrayBufferByteLength() { 6246 return HObjectAccess::ForObservableJSObjectOffset( 6247 JSArrayBuffer::kByteLengthOffset, Representation::Tagged()); 6248 } 6249 6250 static HObjectAccess ForExternalArrayExternalPointer() { 6251 return HObjectAccess::ForObservableJSObjectOffset( 6252 ExternalArray::kExternalPointerOffset, Representation::External()); 6253 } 6254 6255 static HObjectAccess ForJSArrayBufferViewWeakNext() { 6256 return HObjectAccess::ForObservableJSObjectOffset( 6257 JSArrayBufferView::kWeakNextOffset); 6258 } 6259 6260 static HObjectAccess ForJSArrayBufferWeakFirstView() { 6261 return HObjectAccess::ForObservableJSObjectOffset( 6262 JSArrayBuffer::kWeakFirstViewOffset); 6263 } 6264 6265 static HObjectAccess ForJSArrayBufferViewBuffer() { 6266 return HObjectAccess::ForObservableJSObjectOffset( 6267 JSArrayBufferView::kBufferOffset); 6268 } 6269 6270 static HObjectAccess ForJSArrayBufferViewByteOffset() { 6271 return HObjectAccess::ForObservableJSObjectOffset( 6272 JSArrayBufferView::kByteOffsetOffset); 6273 } 6274 6275 static HObjectAccess ForJSArrayBufferViewByteLength() { 6276 return HObjectAccess::ForObservableJSObjectOffset( 6277 JSArrayBufferView::kByteLengthOffset); 6278 } 6279 6280 static HObjectAccess ForGlobalObjectNativeContext() { 6281 return HObjectAccess(kInobject, GlobalObject::kNativeContextOffset); 6282 } 6283 6284 inline bool Equals(HObjectAccess that) const { 6285 return value_ == that.value_; // portion and offset must match 6286 } 6287 6288 protected: 6289 void SetGVNFlags(HValue *instr, PropertyAccessType access_type); 6290 6291 private: 6292 // internal use only; different parts of an object or array 6293 enum Portion { 6294 kMaps, // map of an object 6295 kArrayLengths, // the length of an array 6296 kStringLengths, // the length of a string 6297 kElementsPointer, // elements pointer 6298 kBackingStore, // some field in the backing store 6299 kDouble, // some double field 6300 kInobject, // some other in-object field 6301 kExternalMemory // some field in external memory 6302 }; 6303 6304 HObjectAccess() : value_(0) {} 6305 6306 HObjectAccess(Portion portion, int offset, 6307 Representation representation = Representation::Tagged(), 6308 Handle<String> name = Handle<String>::null(), 6309 bool immutable = false, 6310 bool existing_inobject_property = true) 6311 : value_(PortionField::encode(portion) | 6312 RepresentationField::encode(representation.kind()) | 6313 ImmutableField::encode(immutable ? 1 : 0) | 6314 ExistingInobjectPropertyField::encode( 6315 existing_inobject_property ? 1 : 0) | 6316 OffsetField::encode(offset)), 6317 name_(name) { 6318 // assert that the fields decode correctly 6319 DCHECK(this->offset() == offset); 6320 DCHECK(this->portion() == portion); 6321 DCHECK(this->immutable() == immutable); 6322 DCHECK(this->existing_inobject_property() == existing_inobject_property); 6323 DCHECK(RepresentationField::decode(value_) == representation.kind()); 6324 DCHECK(!this->existing_inobject_property() || IsInobject()); 6325 } 6326 6327 class PortionField : public BitField<Portion, 0, 3> {}; 6328 class RepresentationField : public BitField<Representation::Kind, 3, 4> {}; 6329 class ImmutableField : public BitField<bool, 7, 1> {}; 6330 class ExistingInobjectPropertyField : public BitField<bool, 8, 1> {}; 6331 class OffsetField : public BitField<int, 9, 23> {}; 6332 6333 uint32_t value_; // encodes portion, representation, immutable, and offset 6334 Handle<String> name_; 6335 6336 friend class HLoadNamedField; 6337 friend class HStoreNamedField; 6338 friend class SideEffectsTracker; 6339 friend OStream& operator<<(OStream& os, const HObjectAccess& access); 6340 6341 inline Portion portion() const { 6342 return PortionField::decode(value_); 6343 } 6344 }; 6345 6346 6347 OStream& operator<<(OStream& os, const HObjectAccess& access); 6348 6349 6350 class HLoadNamedField FINAL : public HTemplateInstruction<2> { 6351 public: 6352 DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*, 6353 HValue*, HObjectAccess); 6354 DECLARE_INSTRUCTION_FACTORY_P5(HLoadNamedField, HValue*, HValue*, 6355 HObjectAccess, const UniqueSet<Map>*, HType); 6356 6357 HValue* object() const { return OperandAt(0); } 6358 HValue* dependency() const { 6359 DCHECK(HasDependency()); 6360 return OperandAt(1); 6361 } 6362 bool HasDependency() const { return OperandAt(0) != OperandAt(1); } 6363 HObjectAccess access() const { return access_; } 6364 Representation field_representation() const { 6365 return access_.representation(); 6366 } 6367 6368 const UniqueSet<Map>* maps() const { return maps_; } 6369 6370 virtual bool HasEscapingOperandAt(int index) OVERRIDE { return false; } 6371 virtual bool HasOutOfBoundsAccess(int size) OVERRIDE { 6372 return !access().IsInobject() || access().offset() >= size; 6373 } 6374 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6375 if (index == 0 && access().IsExternalMemory()) { 6376 // object must be external in case of external memory access 6377 return Representation::External(); 6378 } 6379 return Representation::Tagged(); 6380 } 6381 virtual Range* InferRange(Zone* zone) OVERRIDE; 6382 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6383 6384 bool CanBeReplacedWith(HValue* other) const { 6385 if (!CheckFlag(HValue::kCantBeReplaced)) return false; 6386 if (!type().Equals(other->type())) return false; 6387 if (!representation().Equals(other->representation())) return false; 6388 if (!other->IsLoadNamedField()) return true; 6389 HLoadNamedField* that = HLoadNamedField::cast(other); 6390 if (this->maps_ == that->maps_) return true; 6391 if (this->maps_ == NULL || that->maps_ == NULL) return false; 6392 return this->maps_->IsSubset(that->maps_); 6393 } 6394 6395 DECLARE_CONCRETE_INSTRUCTION(LoadNamedField) 6396 6397 protected: 6398 virtual bool DataEquals(HValue* other) OVERRIDE { 6399 HLoadNamedField* that = HLoadNamedField::cast(other); 6400 if (!this->access_.Equals(that->access_)) return false; 6401 if (this->maps_ == that->maps_) return true; 6402 return (this->maps_ != NULL && 6403 that->maps_ != NULL && 6404 this->maps_->Equals(that->maps_)); 6405 } 6406 6407 private: 6408 HLoadNamedField(HValue* object, 6409 HValue* dependency, 6410 HObjectAccess access) 6411 : access_(access), maps_(NULL) { 6412 DCHECK_NOT_NULL(object); 6413 SetOperandAt(0, object); 6414 SetOperandAt(1, dependency ? dependency : object); 6415 6416 Representation representation = access.representation(); 6417 if (representation.IsInteger8() || 6418 representation.IsUInteger8() || 6419 representation.IsInteger16() || 6420 representation.IsUInteger16()) { 6421 set_representation(Representation::Integer32()); 6422 } else if (representation.IsSmi()) { 6423 set_type(HType::Smi()); 6424 if (SmiValuesAre32Bits()) { 6425 set_representation(Representation::Integer32()); 6426 } else { 6427 set_representation(representation); 6428 } 6429 } else if (representation.IsDouble() || 6430 representation.IsExternal() || 6431 representation.IsInteger32()) { 6432 set_representation(representation); 6433 } else if (representation.IsHeapObject()) { 6434 set_type(HType::HeapObject()); 6435 set_representation(Representation::Tagged()); 6436 } else { 6437 set_representation(Representation::Tagged()); 6438 } 6439 access.SetGVNFlags(this, LOAD); 6440 } 6441 6442 HLoadNamedField(HValue* object, 6443 HValue* dependency, 6444 HObjectAccess access, 6445 const UniqueSet<Map>* maps, 6446 HType type) 6447 : HTemplateInstruction<2>(type), access_(access), maps_(maps) { 6448 DCHECK_NOT_NULL(maps); 6449 DCHECK_NE(0, maps->size()); 6450 6451 DCHECK_NOT_NULL(object); 6452 SetOperandAt(0, object); 6453 SetOperandAt(1, dependency ? dependency : object); 6454 6455 DCHECK(access.representation().IsHeapObject()); 6456 DCHECK(type.IsHeapObject()); 6457 set_representation(Representation::Tagged()); 6458 6459 access.SetGVNFlags(this, LOAD); 6460 } 6461 6462 virtual bool IsDeletable() const OVERRIDE { return true; } 6463 6464 HObjectAccess access_; 6465 const UniqueSet<Map>* maps_; 6466 }; 6467 6468 6469 class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> { 6470 public: 6471 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HLoadNamedGeneric, HValue*, 6472 Handle<Object>); 6473 6474 HValue* context() const { return OperandAt(0); } 6475 HValue* object() const { return OperandAt(1); } 6476 Handle<Object> name() const { return name_; } 6477 6478 int slot() const { 6479 DCHECK(FLAG_vector_ics && 6480 slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot); 6481 return slot_; 6482 } 6483 Handle<FixedArray> feedback_vector() const { return feedback_vector_; } 6484 void SetVectorAndSlot(Handle<FixedArray> vector, int slot) { 6485 DCHECK(FLAG_vector_ics); 6486 feedback_vector_ = vector; 6487 slot_ = slot; 6488 } 6489 6490 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6491 return Representation::Tagged(); 6492 } 6493 6494 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6495 6496 DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric) 6497 6498 private: 6499 HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name) 6500 : name_(name), 6501 slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) { 6502 SetOperandAt(0, context); 6503 SetOperandAt(1, object); 6504 set_representation(Representation::Tagged()); 6505 SetAllSideEffects(); 6506 } 6507 6508 Handle<Object> name_; 6509 Handle<FixedArray> feedback_vector_; 6510 int slot_; 6511 }; 6512 6513 6514 class HLoadFunctionPrototype FINAL : public HUnaryOperation { 6515 public: 6516 DECLARE_INSTRUCTION_FACTORY_P1(HLoadFunctionPrototype, HValue*); 6517 6518 HValue* function() { return OperandAt(0); } 6519 6520 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6521 return Representation::Tagged(); 6522 } 6523 6524 DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype) 6525 6526 protected: 6527 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 6528 6529 private: 6530 explicit HLoadFunctionPrototype(HValue* function) 6531 : HUnaryOperation(function) { 6532 set_representation(Representation::Tagged()); 6533 SetFlag(kUseGVN); 6534 SetDependsOnFlag(kCalls); 6535 } 6536 }; 6537 6538 class ArrayInstructionInterface { 6539 public: 6540 virtual HValue* GetKey() = 0; 6541 virtual void SetKey(HValue* key) = 0; 6542 virtual ElementsKind elements_kind() const = 0; 6543 // TryIncreaseBaseOffset returns false if overflow would result. 6544 virtual bool TryIncreaseBaseOffset(uint32_t increase_by_value) = 0; 6545 virtual bool IsDehoisted() const = 0; 6546 virtual void SetDehoisted(bool is_dehoisted) = 0; 6547 virtual ~ArrayInstructionInterface() { } 6548 6549 static Representation KeyedAccessIndexRequirement(Representation r) { 6550 return r.IsInteger32() || SmiValuesAre32Bits() 6551 ? Representation::Integer32() : Representation::Smi(); 6552 } 6553 }; 6554 6555 6556 static const int kDefaultKeyedHeaderOffsetSentinel = -1; 6557 6558 enum LoadKeyedHoleMode { 6559 NEVER_RETURN_HOLE, 6560 ALLOW_RETURN_HOLE 6561 }; 6562 6563 6564 class HLoadKeyed FINAL 6565 : public HTemplateInstruction<3>, public ArrayInstructionInterface { 6566 public: 6567 DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*, 6568 ElementsKind); 6569 DECLARE_INSTRUCTION_FACTORY_P5(HLoadKeyed, HValue*, HValue*, HValue*, 6570 ElementsKind, LoadKeyedHoleMode); 6571 DECLARE_INSTRUCTION_FACTORY_P6(HLoadKeyed, HValue*, HValue*, HValue*, 6572 ElementsKind, LoadKeyedHoleMode, int); 6573 6574 bool is_external() const { 6575 return IsExternalArrayElementsKind(elements_kind()); 6576 } 6577 bool is_fixed_typed_array() const { 6578 return IsFixedTypedArrayElementsKind(elements_kind()); 6579 } 6580 bool is_typed_elements() const { 6581 return is_external() || is_fixed_typed_array(); 6582 } 6583 HValue* elements() const { return OperandAt(0); } 6584 HValue* key() const { return OperandAt(1); } 6585 HValue* dependency() const { 6586 DCHECK(HasDependency()); 6587 return OperandAt(2); 6588 } 6589 bool HasDependency() const { return OperandAt(0) != OperandAt(2); } 6590 uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); } 6591 bool TryIncreaseBaseOffset(uint32_t increase_by_value); 6592 HValue* GetKey() { return key(); } 6593 void SetKey(HValue* key) { SetOperandAt(1, key); } 6594 bool IsDehoisted() const { return IsDehoistedField::decode(bit_field_); } 6595 void SetDehoisted(bool is_dehoisted) { 6596 bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted); 6597 } 6598 virtual ElementsKind elements_kind() const OVERRIDE { 6599 return ElementsKindField::decode(bit_field_); 6600 } 6601 LoadKeyedHoleMode hole_mode() const { 6602 return HoleModeField::decode(bit_field_); 6603 } 6604 6605 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6606 // kind_fast: tagged[int32] (none) 6607 // kind_double: tagged[int32] (none) 6608 // kind_fixed_typed_array: tagged[int32] (none) 6609 // kind_external: external[int32] (none) 6610 if (index == 0) { 6611 return is_external() ? Representation::External() 6612 : Representation::Tagged(); 6613 } 6614 if (index == 1) { 6615 return ArrayInstructionInterface::KeyedAccessIndexRequirement( 6616 OperandAt(1)->representation()); 6617 } 6618 return Representation::None(); 6619 } 6620 6621 virtual Representation observed_input_representation(int index) OVERRIDE { 6622 return RequiredInputRepresentation(index); 6623 } 6624 6625 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6626 6627 bool UsesMustHandleHole() const; 6628 bool AllUsesCanTreatHoleAsNaN() const; 6629 bool RequiresHoleCheck() const; 6630 6631 virtual Range* InferRange(Zone* zone) OVERRIDE; 6632 6633 DECLARE_CONCRETE_INSTRUCTION(LoadKeyed) 6634 6635 protected: 6636 virtual bool DataEquals(HValue* other) OVERRIDE { 6637 if (!other->IsLoadKeyed()) return false; 6638 HLoadKeyed* other_load = HLoadKeyed::cast(other); 6639 6640 if (IsDehoisted() && base_offset() != other_load->base_offset()) 6641 return false; 6642 return elements_kind() == other_load->elements_kind(); 6643 } 6644 6645 private: 6646 HLoadKeyed(HValue* obj, 6647 HValue* key, 6648 HValue* dependency, 6649 ElementsKind elements_kind, 6650 LoadKeyedHoleMode mode = NEVER_RETURN_HOLE, 6651 int offset = kDefaultKeyedHeaderOffsetSentinel) 6652 : bit_field_(0) { 6653 offset = offset == kDefaultKeyedHeaderOffsetSentinel 6654 ? GetDefaultHeaderSizeForElementsKind(elements_kind) 6655 : offset; 6656 bit_field_ = ElementsKindField::encode(elements_kind) | 6657 HoleModeField::encode(mode) | 6658 BaseOffsetField::encode(offset); 6659 6660 SetOperandAt(0, obj); 6661 SetOperandAt(1, key); 6662 SetOperandAt(2, dependency != NULL ? dependency : obj); 6663 6664 if (!is_typed_elements()) { 6665 // I can detect the case between storing double (holey and fast) and 6666 // smi/object by looking at elements_kind_. 6667 DCHECK(IsFastSmiOrObjectElementsKind(elements_kind) || 6668 IsFastDoubleElementsKind(elements_kind)); 6669 6670 if (IsFastSmiOrObjectElementsKind(elements_kind)) { 6671 if (IsFastSmiElementsKind(elements_kind) && 6672 (!IsHoleyElementsKind(elements_kind) || 6673 mode == NEVER_RETURN_HOLE)) { 6674 set_type(HType::Smi()); 6675 if (SmiValuesAre32Bits() && !RequiresHoleCheck()) { 6676 set_representation(Representation::Integer32()); 6677 } else { 6678 set_representation(Representation::Smi()); 6679 } 6680 } else { 6681 set_representation(Representation::Tagged()); 6682 } 6683 6684 SetDependsOnFlag(kArrayElements); 6685 } else { 6686 set_representation(Representation::Double()); 6687 SetDependsOnFlag(kDoubleArrayElements); 6688 } 6689 } else { 6690 if (elements_kind == EXTERNAL_FLOAT32_ELEMENTS || 6691 elements_kind == EXTERNAL_FLOAT64_ELEMENTS || 6692 elements_kind == FLOAT32_ELEMENTS || 6693 elements_kind == FLOAT64_ELEMENTS) { 6694 set_representation(Representation::Double()); 6695 } else { 6696 set_representation(Representation::Integer32()); 6697 } 6698 6699 if (is_external()) { 6700 SetDependsOnFlag(kExternalMemory); 6701 } else if (is_fixed_typed_array()) { 6702 SetDependsOnFlag(kTypedArrayElements); 6703 } else { 6704 UNREACHABLE(); 6705 } 6706 // Native code could change the specialized array. 6707 SetDependsOnFlag(kCalls); 6708 } 6709 6710 SetFlag(kUseGVN); 6711 } 6712 6713 virtual bool IsDeletable() const OVERRIDE { 6714 return !RequiresHoleCheck(); 6715 } 6716 6717 // Establish some checks around our packed fields 6718 enum LoadKeyedBits { 6719 kBitsForElementsKind = 5, 6720 kBitsForHoleMode = 1, 6721 kBitsForBaseOffset = 25, 6722 kBitsForIsDehoisted = 1, 6723 6724 kStartElementsKind = 0, 6725 kStartHoleMode = kStartElementsKind + kBitsForElementsKind, 6726 kStartBaseOffset = kStartHoleMode + kBitsForHoleMode, 6727 kStartIsDehoisted = kStartBaseOffset + kBitsForBaseOffset 6728 }; 6729 6730 STATIC_ASSERT((kBitsForElementsKind + kBitsForBaseOffset + 6731 kBitsForIsDehoisted) <= sizeof(uint32_t)*8); 6732 STATIC_ASSERT(kElementsKindCount <= (1 << kBitsForElementsKind)); 6733 class ElementsKindField: 6734 public BitField<ElementsKind, kStartElementsKind, kBitsForElementsKind> 6735 {}; // NOLINT 6736 class HoleModeField: 6737 public BitField<LoadKeyedHoleMode, kStartHoleMode, kBitsForHoleMode> 6738 {}; // NOLINT 6739 class BaseOffsetField: 6740 public BitField<uint32_t, kStartBaseOffset, kBitsForBaseOffset> 6741 {}; // NOLINT 6742 class IsDehoistedField: 6743 public BitField<bool, kStartIsDehoisted, kBitsForIsDehoisted> 6744 {}; // NOLINT 6745 uint32_t bit_field_; 6746 }; 6747 6748 6749 class HLoadKeyedGeneric FINAL : public HTemplateInstruction<3> { 6750 public: 6751 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HLoadKeyedGeneric, HValue*, 6752 HValue*); 6753 HValue* object() const { return OperandAt(0); } 6754 HValue* key() const { return OperandAt(1); } 6755 HValue* context() const { return OperandAt(2); } 6756 int slot() const { 6757 DCHECK(FLAG_vector_ics && 6758 slot_ != FeedbackSlotInterface::kInvalidFeedbackSlot); 6759 return slot_; 6760 } 6761 Handle<FixedArray> feedback_vector() const { return feedback_vector_; } 6762 void SetVectorAndSlot(Handle<FixedArray> vector, int slot) { 6763 DCHECK(FLAG_vector_ics); 6764 feedback_vector_ = vector; 6765 slot_ = slot; 6766 } 6767 6768 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6769 6770 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6771 // tagged[tagged] 6772 return Representation::Tagged(); 6773 } 6774 6775 virtual HValue* Canonicalize() OVERRIDE; 6776 6777 DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric) 6778 6779 private: 6780 HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key) 6781 : slot_(FeedbackSlotInterface::kInvalidFeedbackSlot) { 6782 set_representation(Representation::Tagged()); 6783 SetOperandAt(0, obj); 6784 SetOperandAt(1, key); 6785 SetOperandAt(2, context); 6786 SetAllSideEffects(); 6787 } 6788 6789 Handle<FixedArray> feedback_vector_; 6790 int slot_; 6791 }; 6792 6793 6794 // Indicates whether the store is a store to an entry that was previously 6795 // initialized or not. 6796 enum StoreFieldOrKeyedMode { 6797 // The entry could be either previously initialized or not. 6798 INITIALIZING_STORE, 6799 // At the time of this store it is guaranteed that the entry is already 6800 // initialized. 6801 STORE_TO_INITIALIZED_ENTRY 6802 }; 6803 6804 6805 class HStoreNamedField FINAL : public HTemplateInstruction<3> { 6806 public: 6807 DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*, 6808 HObjectAccess, HValue*); 6809 DECLARE_INSTRUCTION_FACTORY_P4(HStoreNamedField, HValue*, 6810 HObjectAccess, HValue*, StoreFieldOrKeyedMode); 6811 6812 DECLARE_CONCRETE_INSTRUCTION(StoreNamedField) 6813 6814 virtual bool HasEscapingOperandAt(int index) OVERRIDE { 6815 return index == 1; 6816 } 6817 virtual bool HasOutOfBoundsAccess(int size) OVERRIDE { 6818 return !access().IsInobject() || access().offset() >= size; 6819 } 6820 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6821 if (index == 0 && access().IsExternalMemory()) { 6822 // object must be external in case of external memory access 6823 return Representation::External(); 6824 } else if (index == 1) { 6825 if (field_representation().IsInteger8() || 6826 field_representation().IsUInteger8() || 6827 field_representation().IsInteger16() || 6828 field_representation().IsUInteger16() || 6829 field_representation().IsInteger32()) { 6830 return Representation::Integer32(); 6831 } else if (field_representation().IsDouble()) { 6832 return field_representation(); 6833 } else if (field_representation().IsSmi()) { 6834 if (SmiValuesAre32Bits() && store_mode_ == STORE_TO_INITIALIZED_ENTRY) { 6835 return Representation::Integer32(); 6836 } 6837 return field_representation(); 6838 } else if (field_representation().IsExternal()) { 6839 return Representation::External(); 6840 } 6841 } 6842 return Representation::Tagged(); 6843 } 6844 virtual bool HandleSideEffectDominator(GVNFlag side_effect, 6845 HValue* dominator) OVERRIDE { 6846 DCHECK(side_effect == kNewSpacePromotion); 6847 if (!FLAG_use_write_barrier_elimination) return false; 6848 dominator_ = dominator; 6849 return false; 6850 } 6851 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6852 6853 HValue* object() const { return OperandAt(0); } 6854 HValue* value() const { return OperandAt(1); } 6855 HValue* transition() const { return OperandAt(2); } 6856 6857 HObjectAccess access() const { return access_; } 6858 HValue* dominator() const { return dominator_; } 6859 bool has_transition() const { return has_transition_; } 6860 StoreFieldOrKeyedMode store_mode() const { return store_mode_; } 6861 6862 Handle<Map> transition_map() const { 6863 if (has_transition()) { 6864 return Handle<Map>::cast( 6865 HConstant::cast(transition())->handle(Isolate::Current())); 6866 } else { 6867 return Handle<Map>(); 6868 } 6869 } 6870 6871 void SetTransition(HConstant* transition) { 6872 DCHECK(!has_transition()); // Only set once. 6873 SetOperandAt(2, transition); 6874 has_transition_ = true; 6875 SetChangesFlag(kMaps); 6876 } 6877 6878 bool NeedsWriteBarrier() const { 6879 DCHECK(!field_representation().IsDouble() || !has_transition()); 6880 if (field_representation().IsDouble()) return false; 6881 if (field_representation().IsSmi()) return false; 6882 if (field_representation().IsInteger32()) return false; 6883 if (field_representation().IsExternal()) return false; 6884 return StoringValueNeedsWriteBarrier(value()) && 6885 ReceiverObjectNeedsWriteBarrier(object(), value(), dominator()); 6886 } 6887 6888 bool NeedsWriteBarrierForMap() { 6889 return ReceiverObjectNeedsWriteBarrier(object(), transition(), 6890 dominator()); 6891 } 6892 6893 SmiCheck SmiCheckForWriteBarrier() const { 6894 if (field_representation().IsHeapObject()) return OMIT_SMI_CHECK; 6895 if (value()->type().IsHeapObject()) return OMIT_SMI_CHECK; 6896 return INLINE_SMI_CHECK; 6897 } 6898 6899 PointersToHereCheck PointersToHereCheckForValue() const { 6900 return PointersToHereCheckForObject(value(), dominator()); 6901 } 6902 6903 Representation field_representation() const { 6904 return access_.representation(); 6905 } 6906 6907 void UpdateValue(HValue* value) { 6908 SetOperandAt(1, value); 6909 } 6910 6911 bool CanBeReplacedWith(HStoreNamedField* that) const { 6912 if (!this->access().Equals(that->access())) return false; 6913 if (SmiValuesAre32Bits() && 6914 this->field_representation().IsSmi() && 6915 this->store_mode() == INITIALIZING_STORE && 6916 that->store_mode() == STORE_TO_INITIALIZED_ENTRY) { 6917 // We cannot replace an initializing store to a smi field with a store to 6918 // an initialized entry on 64-bit architectures (with 32-bit smis). 6919 return false; 6920 } 6921 return true; 6922 } 6923 6924 private: 6925 HStoreNamedField(HValue* obj, 6926 HObjectAccess access, 6927 HValue* val, 6928 StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE) 6929 : access_(access), 6930 dominator_(NULL), 6931 has_transition_(false), 6932 store_mode_(store_mode) { 6933 // Stores to a non existing in-object property are allowed only to the 6934 // newly allocated objects (via HAllocate or HInnerAllocatedObject). 6935 DCHECK(!access.IsInobject() || access.existing_inobject_property() || 6936 obj->IsAllocate() || obj->IsInnerAllocatedObject()); 6937 SetOperandAt(0, obj); 6938 SetOperandAt(1, val); 6939 SetOperandAt(2, obj); 6940 access.SetGVNFlags(this, STORE); 6941 } 6942 6943 HObjectAccess access_; 6944 HValue* dominator_; 6945 bool has_transition_ : 1; 6946 StoreFieldOrKeyedMode store_mode_ : 1; 6947 }; 6948 6949 6950 class HStoreNamedGeneric FINAL : public HTemplateInstruction<3> { 6951 public: 6952 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HStoreNamedGeneric, HValue*, 6953 Handle<String>, HValue*, 6954 StrictMode); 6955 HValue* object() const { return OperandAt(0); } 6956 HValue* value() const { return OperandAt(1); } 6957 HValue* context() const { return OperandAt(2); } 6958 Handle<String> name() const { return name_; } 6959 StrictMode strict_mode() const { return strict_mode_; } 6960 6961 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 6962 6963 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6964 return Representation::Tagged(); 6965 } 6966 6967 DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric) 6968 6969 private: 6970 HStoreNamedGeneric(HValue* context, 6971 HValue* object, 6972 Handle<String> name, 6973 HValue* value, 6974 StrictMode strict_mode) 6975 : name_(name), 6976 strict_mode_(strict_mode) { 6977 SetOperandAt(0, object); 6978 SetOperandAt(1, value); 6979 SetOperandAt(2, context); 6980 SetAllSideEffects(); 6981 } 6982 6983 Handle<String> name_; 6984 StrictMode strict_mode_; 6985 }; 6986 6987 6988 class HStoreKeyed FINAL 6989 : public HTemplateInstruction<3>, public ArrayInstructionInterface { 6990 public: 6991 DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*, 6992 ElementsKind); 6993 DECLARE_INSTRUCTION_FACTORY_P5(HStoreKeyed, HValue*, HValue*, HValue*, 6994 ElementsKind, StoreFieldOrKeyedMode); 6995 DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*, 6996 ElementsKind, StoreFieldOrKeyedMode, int); 6997 6998 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 6999 // kind_fast: tagged[int32] = tagged 7000 // kind_double: tagged[int32] = double 7001 // kind_smi : tagged[int32] = smi 7002 // kind_fixed_typed_array: tagged[int32] = (double | int32) 7003 // kind_external: external[int32] = (double | int32) 7004 if (index == 0) { 7005 return is_external() ? Representation::External() 7006 : Representation::Tagged(); 7007 } else if (index == 1) { 7008 return ArrayInstructionInterface::KeyedAccessIndexRequirement( 7009 OperandAt(1)->representation()); 7010 } 7011 7012 DCHECK_EQ(index, 2); 7013 return RequiredValueRepresentation(elements_kind_, store_mode_); 7014 } 7015 7016 static Representation RequiredValueRepresentation( 7017 ElementsKind kind, StoreFieldOrKeyedMode mode) { 7018 if (IsDoubleOrFloatElementsKind(kind)) { 7019 return Representation::Double(); 7020 } 7021 7022 if (kind == FAST_SMI_ELEMENTS && SmiValuesAre32Bits() && 7023 mode == STORE_TO_INITIALIZED_ENTRY) { 7024 return Representation::Integer32(); 7025 } 7026 7027 if (IsFastSmiElementsKind(kind)) { 7028 return Representation::Smi(); 7029 } 7030 7031 return IsExternalArrayElementsKind(kind) || 7032 IsFixedTypedArrayElementsKind(kind) 7033 ? Representation::Integer32() 7034 : Representation::Tagged(); 7035 } 7036 7037 bool is_external() const { 7038 return IsExternalArrayElementsKind(elements_kind()); 7039 } 7040 7041 bool is_fixed_typed_array() const { 7042 return IsFixedTypedArrayElementsKind(elements_kind()); 7043 } 7044 7045 bool is_typed_elements() const { 7046 return is_external() || is_fixed_typed_array(); 7047 } 7048 7049 virtual Representation observed_input_representation(int index) OVERRIDE { 7050 if (index < 2) return RequiredInputRepresentation(index); 7051 if (IsUninitialized()) { 7052 return Representation::None(); 7053 } 7054 Representation r = RequiredValueRepresentation(elements_kind_, store_mode_); 7055 // For fast object elements kinds, don't assume anything. 7056 if (r.IsTagged()) return Representation::None(); 7057 return r; 7058 } 7059 7060 HValue* elements() const { return OperandAt(0); } 7061 HValue* key() const { return OperandAt(1); } 7062 HValue* value() const { return OperandAt(2); } 7063 bool value_is_smi() const { 7064 return IsFastSmiElementsKind(elements_kind_); 7065 } 7066 StoreFieldOrKeyedMode store_mode() const { return store_mode_; } 7067 ElementsKind elements_kind() const { return elements_kind_; } 7068 uint32_t base_offset() const { return base_offset_; } 7069 bool TryIncreaseBaseOffset(uint32_t increase_by_value); 7070 HValue* GetKey() { return key(); } 7071 void SetKey(HValue* key) { SetOperandAt(1, key); } 7072 bool IsDehoisted() const { return is_dehoisted_; } 7073 void SetDehoisted(bool is_dehoisted) { is_dehoisted_ = is_dehoisted; } 7074 bool IsUninitialized() { return is_uninitialized_; } 7075 void SetUninitialized(bool is_uninitialized) { 7076 is_uninitialized_ = is_uninitialized; 7077 } 7078 7079 bool IsConstantHoleStore() { 7080 return value()->IsConstant() && HConstant::cast(value())->IsTheHole(); 7081 } 7082 7083 virtual bool HandleSideEffectDominator(GVNFlag side_effect, 7084 HValue* dominator) OVERRIDE { 7085 DCHECK(side_effect == kNewSpacePromotion); 7086 dominator_ = dominator; 7087 return false; 7088 } 7089 7090 HValue* dominator() const { return dominator_; } 7091 7092 bool NeedsWriteBarrier() { 7093 if (value_is_smi()) { 7094 return false; 7095 } else { 7096 return StoringValueNeedsWriteBarrier(value()) && 7097 ReceiverObjectNeedsWriteBarrier(elements(), value(), dominator()); 7098 } 7099 } 7100 7101 PointersToHereCheck PointersToHereCheckForValue() const { 7102 return PointersToHereCheckForObject(value(), dominator()); 7103 } 7104 7105 bool NeedsCanonicalization(); 7106 7107 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7108 7109 DECLARE_CONCRETE_INSTRUCTION(StoreKeyed) 7110 7111 private: 7112 HStoreKeyed(HValue* obj, HValue* key, HValue* val, 7113 ElementsKind elements_kind, 7114 StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE, 7115 int offset = kDefaultKeyedHeaderOffsetSentinel) 7116 : elements_kind_(elements_kind), 7117 base_offset_(offset == kDefaultKeyedHeaderOffsetSentinel 7118 ? GetDefaultHeaderSizeForElementsKind(elements_kind) 7119 : offset), 7120 is_dehoisted_(false), 7121 is_uninitialized_(false), 7122 store_mode_(store_mode), 7123 dominator_(NULL) { 7124 SetOperandAt(0, obj); 7125 SetOperandAt(1, key); 7126 SetOperandAt(2, val); 7127 7128 if (IsFastObjectElementsKind(elements_kind)) { 7129 SetFlag(kTrackSideEffectDominators); 7130 SetDependsOnFlag(kNewSpacePromotion); 7131 } 7132 if (is_external()) { 7133 SetChangesFlag(kExternalMemory); 7134 SetFlag(kAllowUndefinedAsNaN); 7135 } else if (IsFastDoubleElementsKind(elements_kind)) { 7136 SetChangesFlag(kDoubleArrayElements); 7137 } else if (IsFastSmiElementsKind(elements_kind)) { 7138 SetChangesFlag(kArrayElements); 7139 } else if (is_fixed_typed_array()) { 7140 SetChangesFlag(kTypedArrayElements); 7141 SetFlag(kAllowUndefinedAsNaN); 7142 } else { 7143 SetChangesFlag(kArrayElements); 7144 } 7145 7146 // EXTERNAL_{UNSIGNED_,}{BYTE,SHORT,INT}_ELEMENTS are truncating. 7147 if ((elements_kind >= EXTERNAL_INT8_ELEMENTS && 7148 elements_kind <= EXTERNAL_UINT32_ELEMENTS) || 7149 (elements_kind >= UINT8_ELEMENTS && 7150 elements_kind <= INT32_ELEMENTS)) { 7151 SetFlag(kTruncatingToInt32); 7152 } 7153 } 7154 7155 ElementsKind elements_kind_; 7156 uint32_t base_offset_; 7157 bool is_dehoisted_ : 1; 7158 bool is_uninitialized_ : 1; 7159 StoreFieldOrKeyedMode store_mode_: 1; 7160 HValue* dominator_; 7161 }; 7162 7163 7164 class HStoreKeyedGeneric FINAL : public HTemplateInstruction<4> { 7165 public: 7166 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HStoreKeyedGeneric, HValue*, 7167 HValue*, HValue*, StrictMode); 7168 7169 HValue* object() const { return OperandAt(0); } 7170 HValue* key() const { return OperandAt(1); } 7171 HValue* value() const { return OperandAt(2); } 7172 HValue* context() const { return OperandAt(3); } 7173 StrictMode strict_mode() const { return strict_mode_; } 7174 7175 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7176 // tagged[tagged] = tagged 7177 return Representation::Tagged(); 7178 } 7179 7180 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7181 7182 DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric) 7183 7184 private: 7185 HStoreKeyedGeneric(HValue* context, 7186 HValue* object, 7187 HValue* key, 7188 HValue* value, 7189 StrictMode strict_mode) 7190 : strict_mode_(strict_mode) { 7191 SetOperandAt(0, object); 7192 SetOperandAt(1, key); 7193 SetOperandAt(2, value); 7194 SetOperandAt(3, context); 7195 SetAllSideEffects(); 7196 } 7197 7198 StrictMode strict_mode_; 7199 }; 7200 7201 7202 class HTransitionElementsKind FINAL : public HTemplateInstruction<2> { 7203 public: 7204 inline static HTransitionElementsKind* New(Zone* zone, 7205 HValue* context, 7206 HValue* object, 7207 Handle<Map> original_map, 7208 Handle<Map> transitioned_map) { 7209 return new(zone) HTransitionElementsKind(context, object, 7210 original_map, transitioned_map); 7211 } 7212 7213 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7214 return Representation::Tagged(); 7215 } 7216 7217 HValue* object() const { return OperandAt(0); } 7218 HValue* context() const { return OperandAt(1); } 7219 Unique<Map> original_map() const { return original_map_; } 7220 Unique<Map> transitioned_map() const { return transitioned_map_; } 7221 ElementsKind from_kind() const { return from_kind_; } 7222 ElementsKind to_kind() const { return to_kind_; } 7223 7224 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7225 7226 DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind) 7227 7228 protected: 7229 virtual bool DataEquals(HValue* other) OVERRIDE { 7230 HTransitionElementsKind* instr = HTransitionElementsKind::cast(other); 7231 return original_map_ == instr->original_map_ && 7232 transitioned_map_ == instr->transitioned_map_; 7233 } 7234 7235 virtual int RedefinedOperandIndex() { return 0; } 7236 7237 private: 7238 HTransitionElementsKind(HValue* context, 7239 HValue* object, 7240 Handle<Map> original_map, 7241 Handle<Map> transitioned_map) 7242 : original_map_(Unique<Map>(original_map)), 7243 transitioned_map_(Unique<Map>(transitioned_map)), 7244 from_kind_(original_map->elements_kind()), 7245 to_kind_(transitioned_map->elements_kind()) { 7246 SetOperandAt(0, object); 7247 SetOperandAt(1, context); 7248 SetFlag(kUseGVN); 7249 SetChangesFlag(kElementsKind); 7250 if (!IsSimpleMapChangeTransition(from_kind_, to_kind_)) { 7251 SetChangesFlag(kElementsPointer); 7252 SetChangesFlag(kNewSpacePromotion); 7253 } 7254 set_representation(Representation::Tagged()); 7255 } 7256 7257 Unique<Map> original_map_; 7258 Unique<Map> transitioned_map_; 7259 ElementsKind from_kind_; 7260 ElementsKind to_kind_; 7261 }; 7262 7263 7264 class HStringAdd FINAL : public HBinaryOperation { 7265 public: 7266 static HInstruction* New(Zone* zone, 7267 HValue* context, 7268 HValue* left, 7269 HValue* right, 7270 PretenureFlag pretenure_flag = NOT_TENURED, 7271 StringAddFlags flags = STRING_ADD_CHECK_BOTH, 7272 Handle<AllocationSite> allocation_site = 7273 Handle<AllocationSite>::null()); 7274 7275 StringAddFlags flags() const { return flags_; } 7276 PretenureFlag pretenure_flag() const { return pretenure_flag_; } 7277 7278 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7279 return Representation::Tagged(); 7280 } 7281 7282 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7283 7284 DECLARE_CONCRETE_INSTRUCTION(StringAdd) 7285 7286 protected: 7287 virtual bool DataEquals(HValue* other) OVERRIDE { 7288 return flags_ == HStringAdd::cast(other)->flags_ && 7289 pretenure_flag_ == HStringAdd::cast(other)->pretenure_flag_; 7290 } 7291 7292 private: 7293 HStringAdd(HValue* context, 7294 HValue* left, 7295 HValue* right, 7296 PretenureFlag pretenure_flag, 7297 StringAddFlags flags, 7298 Handle<AllocationSite> allocation_site) 7299 : HBinaryOperation(context, left, right, HType::String()), 7300 flags_(flags), pretenure_flag_(pretenure_flag) { 7301 set_representation(Representation::Tagged()); 7302 SetFlag(kUseGVN); 7303 SetDependsOnFlag(kMaps); 7304 SetChangesFlag(kNewSpacePromotion); 7305 if (FLAG_trace_pretenuring) { 7306 PrintF("HStringAdd with AllocationSite %p %s\n", 7307 allocation_site.is_null() 7308 ? static_cast<void*>(NULL) 7309 : static_cast<void*>(*allocation_site), 7310 pretenure_flag == TENURED ? "tenured" : "not tenured"); 7311 } 7312 } 7313 7314 // No side-effects except possible allocation: 7315 virtual bool IsDeletable() const OVERRIDE { return true; } 7316 7317 const StringAddFlags flags_; 7318 const PretenureFlag pretenure_flag_; 7319 }; 7320 7321 7322 class HStringCharCodeAt FINAL : public HTemplateInstruction<3> { 7323 public: 7324 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HStringCharCodeAt, 7325 HValue*, 7326 HValue*); 7327 7328 virtual Representation RequiredInputRepresentation(int index) { 7329 // The index is supposed to be Integer32. 7330 return index == 2 7331 ? Representation::Integer32() 7332 : Representation::Tagged(); 7333 } 7334 7335 HValue* context() const { return OperandAt(0); } 7336 HValue* string() const { return OperandAt(1); } 7337 HValue* index() const { return OperandAt(2); } 7338 7339 DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt) 7340 7341 protected: 7342 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 7343 7344 virtual Range* InferRange(Zone* zone) OVERRIDE { 7345 return new(zone) Range(0, String::kMaxUtf16CodeUnit); 7346 } 7347 7348 private: 7349 HStringCharCodeAt(HValue* context, HValue* string, HValue* index) { 7350 SetOperandAt(0, context); 7351 SetOperandAt(1, string); 7352 SetOperandAt(2, index); 7353 set_representation(Representation::Integer32()); 7354 SetFlag(kUseGVN); 7355 SetDependsOnFlag(kMaps); 7356 SetDependsOnFlag(kStringChars); 7357 SetChangesFlag(kNewSpacePromotion); 7358 } 7359 7360 // No side effects: runtime function assumes string + number inputs. 7361 virtual bool IsDeletable() const OVERRIDE { return true; } 7362 }; 7363 7364 7365 class HStringCharFromCode FINAL : public HTemplateInstruction<2> { 7366 public: 7367 static HInstruction* New(Zone* zone, 7368 HValue* context, 7369 HValue* char_code); 7370 7371 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7372 return index == 0 7373 ? Representation::Tagged() 7374 : Representation::Integer32(); 7375 } 7376 7377 HValue* context() const { return OperandAt(0); } 7378 HValue* value() const { return OperandAt(1); } 7379 7380 virtual bool DataEquals(HValue* other) OVERRIDE { return true; } 7381 7382 DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode) 7383 7384 private: 7385 HStringCharFromCode(HValue* context, HValue* char_code) 7386 : HTemplateInstruction<2>(HType::String()) { 7387 SetOperandAt(0, context); 7388 SetOperandAt(1, char_code); 7389 set_representation(Representation::Tagged()); 7390 SetFlag(kUseGVN); 7391 SetChangesFlag(kNewSpacePromotion); 7392 } 7393 7394 virtual bool IsDeletable() const OVERRIDE { 7395 return !value()->ToNumberCanBeObserved(); 7396 } 7397 }; 7398 7399 7400 template <int V> 7401 class HMaterializedLiteral : public HTemplateInstruction<V> { 7402 public: 7403 HMaterializedLiteral<V>(int index, int depth, AllocationSiteMode mode) 7404 : literal_index_(index), depth_(depth), allocation_site_mode_(mode) { 7405 this->set_representation(Representation::Tagged()); 7406 } 7407 7408 HMaterializedLiteral<V>(int index, int depth) 7409 : literal_index_(index), depth_(depth), 7410 allocation_site_mode_(DONT_TRACK_ALLOCATION_SITE) { 7411 this->set_representation(Representation::Tagged()); 7412 } 7413 7414 int literal_index() const { return literal_index_; } 7415 int depth() const { return depth_; } 7416 AllocationSiteMode allocation_site_mode() const { 7417 return allocation_site_mode_; 7418 } 7419 7420 private: 7421 virtual bool IsDeletable() const FINAL OVERRIDE { return true; } 7422 7423 int literal_index_; 7424 int depth_; 7425 AllocationSiteMode allocation_site_mode_; 7426 }; 7427 7428 7429 class HRegExpLiteral FINAL : public HMaterializedLiteral<1> { 7430 public: 7431 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HRegExpLiteral, 7432 Handle<FixedArray>, 7433 Handle<String>, 7434 Handle<String>, 7435 int); 7436 7437 HValue* context() { return OperandAt(0); } 7438 Handle<FixedArray> literals() { return literals_; } 7439 Handle<String> pattern() { return pattern_; } 7440 Handle<String> flags() { return flags_; } 7441 7442 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7443 return Representation::Tagged(); 7444 } 7445 7446 DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral) 7447 7448 private: 7449 HRegExpLiteral(HValue* context, 7450 Handle<FixedArray> literals, 7451 Handle<String> pattern, 7452 Handle<String> flags, 7453 int literal_index) 7454 : HMaterializedLiteral<1>(literal_index, 0), 7455 literals_(literals), 7456 pattern_(pattern), 7457 flags_(flags) { 7458 SetOperandAt(0, context); 7459 SetAllSideEffects(); 7460 set_type(HType::JSObject()); 7461 } 7462 7463 Handle<FixedArray> literals_; 7464 Handle<String> pattern_; 7465 Handle<String> flags_; 7466 }; 7467 7468 7469 class HFunctionLiteral FINAL : public HTemplateInstruction<1> { 7470 public: 7471 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HFunctionLiteral, 7472 Handle<SharedFunctionInfo>, 7473 bool); 7474 HValue* context() { return OperandAt(0); } 7475 7476 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7477 return Representation::Tagged(); 7478 } 7479 7480 DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral) 7481 7482 Handle<SharedFunctionInfo> shared_info() const { return shared_info_; } 7483 bool pretenure() const { return pretenure_; } 7484 bool has_no_literals() const { return has_no_literals_; } 7485 bool is_arrow() const { return IsArrowFunction(kind_); } 7486 bool is_generator() const { return IsGeneratorFunction(kind_); } 7487 bool is_concise_method() const { return IsConciseMethod(kind_); } 7488 FunctionKind kind() const { return kind_; } 7489 StrictMode strict_mode() const { return strict_mode_; } 7490 7491 private: 7492 HFunctionLiteral(HValue* context, Handle<SharedFunctionInfo> shared, 7493 bool pretenure) 7494 : HTemplateInstruction<1>(HType::JSObject()), 7495 shared_info_(shared), 7496 kind_(shared->kind()), 7497 pretenure_(pretenure), 7498 has_no_literals_(shared->num_literals() == 0), 7499 strict_mode_(shared->strict_mode()) { 7500 SetOperandAt(0, context); 7501 set_representation(Representation::Tagged()); 7502 SetChangesFlag(kNewSpacePromotion); 7503 } 7504 7505 virtual bool IsDeletable() const OVERRIDE { return true; } 7506 7507 Handle<SharedFunctionInfo> shared_info_; 7508 FunctionKind kind_; 7509 bool pretenure_ : 1; 7510 bool has_no_literals_ : 1; 7511 StrictMode strict_mode_; 7512 }; 7513 7514 7515 class HTypeof FINAL : public HTemplateInstruction<2> { 7516 public: 7517 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HTypeof, HValue*); 7518 7519 HValue* context() const { return OperandAt(0); } 7520 HValue* value() const { return OperandAt(1); } 7521 7522 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7523 7524 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7525 return Representation::Tagged(); 7526 } 7527 7528 DECLARE_CONCRETE_INSTRUCTION(Typeof) 7529 7530 private: 7531 explicit HTypeof(HValue* context, HValue* value) { 7532 SetOperandAt(0, context); 7533 SetOperandAt(1, value); 7534 set_representation(Representation::Tagged()); 7535 } 7536 7537 virtual bool IsDeletable() const OVERRIDE { return true; } 7538 }; 7539 7540 7541 class HTrapAllocationMemento FINAL : public HTemplateInstruction<1> { 7542 public: 7543 DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*); 7544 7545 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7546 return Representation::Tagged(); 7547 } 7548 7549 HValue* object() { return OperandAt(0); } 7550 7551 DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento) 7552 7553 private: 7554 explicit HTrapAllocationMemento(HValue* obj) { 7555 SetOperandAt(0, obj); 7556 } 7557 }; 7558 7559 7560 class HToFastProperties FINAL : public HUnaryOperation { 7561 public: 7562 DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*); 7563 7564 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7565 return Representation::Tagged(); 7566 } 7567 7568 DECLARE_CONCRETE_INSTRUCTION(ToFastProperties) 7569 7570 private: 7571 explicit HToFastProperties(HValue* value) : HUnaryOperation(value) { 7572 set_representation(Representation::Tagged()); 7573 SetChangesFlag(kNewSpacePromotion); 7574 7575 // This instruction is not marked as kChangesMaps, but does 7576 // change the map of the input operand. Use it only when creating 7577 // object literals via a runtime call. 7578 DCHECK(value->IsCallRuntime()); 7579 #ifdef DEBUG 7580 const Runtime::Function* function = HCallRuntime::cast(value)->function(); 7581 DCHECK(function->function_id == Runtime::kCreateObjectLiteral); 7582 #endif 7583 } 7584 7585 virtual bool IsDeletable() const OVERRIDE { return true; } 7586 }; 7587 7588 7589 class HDateField FINAL : public HUnaryOperation { 7590 public: 7591 DECLARE_INSTRUCTION_FACTORY_P2(HDateField, HValue*, Smi*); 7592 7593 Smi* index() const { return index_; } 7594 7595 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7596 return Representation::Tagged(); 7597 } 7598 7599 DECLARE_CONCRETE_INSTRUCTION(DateField) 7600 7601 private: 7602 HDateField(HValue* date, Smi* index) 7603 : HUnaryOperation(date), index_(index) { 7604 set_representation(Representation::Tagged()); 7605 } 7606 7607 Smi* index_; 7608 }; 7609 7610 7611 class HSeqStringGetChar FINAL : public HTemplateInstruction<2> { 7612 public: 7613 static HInstruction* New(Zone* zone, 7614 HValue* context, 7615 String::Encoding encoding, 7616 HValue* string, 7617 HValue* index); 7618 7619 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7620 return (index == 0) ? Representation::Tagged() 7621 : Representation::Integer32(); 7622 } 7623 7624 String::Encoding encoding() const { return encoding_; } 7625 HValue* string() const { return OperandAt(0); } 7626 HValue* index() const { return OperandAt(1); } 7627 7628 DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar) 7629 7630 protected: 7631 virtual bool DataEquals(HValue* other) OVERRIDE { 7632 return encoding() == HSeqStringGetChar::cast(other)->encoding(); 7633 } 7634 7635 virtual Range* InferRange(Zone* zone) OVERRIDE { 7636 if (encoding() == String::ONE_BYTE_ENCODING) { 7637 return new(zone) Range(0, String::kMaxOneByteCharCode); 7638 } else { 7639 DCHECK_EQ(String::TWO_BYTE_ENCODING, encoding()); 7640 return new(zone) Range(0, String::kMaxUtf16CodeUnit); 7641 } 7642 } 7643 7644 private: 7645 HSeqStringGetChar(String::Encoding encoding, 7646 HValue* string, 7647 HValue* index) : encoding_(encoding) { 7648 SetOperandAt(0, string); 7649 SetOperandAt(1, index); 7650 set_representation(Representation::Integer32()); 7651 SetFlag(kUseGVN); 7652 SetDependsOnFlag(kStringChars); 7653 } 7654 7655 virtual bool IsDeletable() const OVERRIDE { return true; } 7656 7657 String::Encoding encoding_; 7658 }; 7659 7660 7661 class HSeqStringSetChar FINAL : public HTemplateInstruction<4> { 7662 public: 7663 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4( 7664 HSeqStringSetChar, String::Encoding, 7665 HValue*, HValue*, HValue*); 7666 7667 String::Encoding encoding() { return encoding_; } 7668 HValue* context() { return OperandAt(0); } 7669 HValue* string() { return OperandAt(1); } 7670 HValue* index() { return OperandAt(2); } 7671 HValue* value() { return OperandAt(3); } 7672 7673 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7674 return (index <= 1) ? Representation::Tagged() 7675 : Representation::Integer32(); 7676 } 7677 7678 DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar) 7679 7680 private: 7681 HSeqStringSetChar(HValue* context, 7682 String::Encoding encoding, 7683 HValue* string, 7684 HValue* index, 7685 HValue* value) : encoding_(encoding) { 7686 SetOperandAt(0, context); 7687 SetOperandAt(1, string); 7688 SetOperandAt(2, index); 7689 SetOperandAt(3, value); 7690 set_representation(Representation::Tagged()); 7691 SetChangesFlag(kStringChars); 7692 } 7693 7694 String::Encoding encoding_; 7695 }; 7696 7697 7698 class HCheckMapValue FINAL : public HTemplateInstruction<2> { 7699 public: 7700 DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*); 7701 7702 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7703 return Representation::Tagged(); 7704 } 7705 7706 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7707 7708 virtual HType CalculateInferredType() OVERRIDE { 7709 if (value()->type().IsHeapObject()) return value()->type(); 7710 return HType::HeapObject(); 7711 } 7712 7713 HValue* value() const { return OperandAt(0); } 7714 HValue* map() const { return OperandAt(1); } 7715 7716 virtual HValue* Canonicalize() OVERRIDE; 7717 7718 DECLARE_CONCRETE_INSTRUCTION(CheckMapValue) 7719 7720 protected: 7721 virtual int RedefinedOperandIndex() { return 0; } 7722 7723 virtual bool DataEquals(HValue* other) OVERRIDE { 7724 return true; 7725 } 7726 7727 private: 7728 HCheckMapValue(HValue* value, HValue* map) 7729 : HTemplateInstruction<2>(HType::HeapObject()) { 7730 SetOperandAt(0, value); 7731 SetOperandAt(1, map); 7732 set_representation(Representation::Tagged()); 7733 SetFlag(kUseGVN); 7734 SetDependsOnFlag(kMaps); 7735 SetDependsOnFlag(kElementsKind); 7736 } 7737 }; 7738 7739 7740 class HForInPrepareMap FINAL : public HTemplateInstruction<2> { 7741 public: 7742 DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HForInPrepareMap, HValue*); 7743 7744 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7745 return Representation::Tagged(); 7746 } 7747 7748 HValue* context() const { return OperandAt(0); } 7749 HValue* enumerable() const { return OperandAt(1); } 7750 7751 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7752 7753 virtual HType CalculateInferredType() OVERRIDE { 7754 return HType::Tagged(); 7755 } 7756 7757 DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap); 7758 7759 private: 7760 HForInPrepareMap(HValue* context, 7761 HValue* object) { 7762 SetOperandAt(0, context); 7763 SetOperandAt(1, object); 7764 set_representation(Representation::Tagged()); 7765 SetAllSideEffects(); 7766 } 7767 }; 7768 7769 7770 class HForInCacheArray FINAL : public HTemplateInstruction<2> { 7771 public: 7772 DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int); 7773 7774 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7775 return Representation::Tagged(); 7776 } 7777 7778 HValue* enumerable() const { return OperandAt(0); } 7779 HValue* map() const { return OperandAt(1); } 7780 int idx() const { return idx_; } 7781 7782 HForInCacheArray* index_cache() { 7783 return index_cache_; 7784 } 7785 7786 void set_index_cache(HForInCacheArray* index_cache) { 7787 index_cache_ = index_cache; 7788 } 7789 7790 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7791 7792 virtual HType CalculateInferredType() OVERRIDE { 7793 return HType::Tagged(); 7794 } 7795 7796 DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray); 7797 7798 private: 7799 HForInCacheArray(HValue* enumerable, 7800 HValue* keys, 7801 int idx) : idx_(idx) { 7802 SetOperandAt(0, enumerable); 7803 SetOperandAt(1, keys); 7804 set_representation(Representation::Tagged()); 7805 } 7806 7807 int idx_; 7808 HForInCacheArray* index_cache_; 7809 }; 7810 7811 7812 class HLoadFieldByIndex FINAL : public HTemplateInstruction<2> { 7813 public: 7814 DECLARE_INSTRUCTION_FACTORY_P2(HLoadFieldByIndex, HValue*, HValue*); 7815 7816 HLoadFieldByIndex(HValue* object, 7817 HValue* index) { 7818 SetOperandAt(0, object); 7819 SetOperandAt(1, index); 7820 SetChangesFlag(kNewSpacePromotion); 7821 set_representation(Representation::Tagged()); 7822 } 7823 7824 virtual Representation RequiredInputRepresentation(int index) OVERRIDE { 7825 if (index == 1) { 7826 return Representation::Smi(); 7827 } else { 7828 return Representation::Tagged(); 7829 } 7830 } 7831 7832 HValue* object() const { return OperandAt(0); } 7833 HValue* index() const { return OperandAt(1); } 7834 7835 virtual OStream& PrintDataTo(OStream& os) const OVERRIDE; // NOLINT 7836 7837 virtual HType CalculateInferredType() OVERRIDE { 7838 return HType::Tagged(); 7839 } 7840 7841 DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex); 7842 7843 private: 7844 virtual bool IsDeletable() const OVERRIDE { return true; } 7845 }; 7846 7847 7848 class HStoreFrameContext: public HUnaryOperation { 7849 public: 7850 DECLARE_INSTRUCTION_FACTORY_P1(HStoreFrameContext, HValue*); 7851 7852 HValue* context() { return OperandAt(0); } 7853 7854 virtual Representation RequiredInputRepresentation(int index) { 7855 return Representation::Tagged(); 7856 } 7857 7858 DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext) 7859 private: 7860 explicit HStoreFrameContext(HValue* context) 7861 : HUnaryOperation(context) { 7862 set_representation(Representation::Tagged()); 7863 SetChangesFlag(kContextSlots); 7864 } 7865 }; 7866 7867 7868 class HAllocateBlockContext: public HTemplateInstruction<2> { 7869 public: 7870 DECLARE_INSTRUCTION_FACTORY_P3(HAllocateBlockContext, HValue*, 7871 HValue*, Handle<ScopeInfo>); 7872 HValue* context() const { return OperandAt(0); } 7873 HValue* function() const { return OperandAt(1); } 7874 Handle<ScopeInfo> scope_info() const { return scope_info_; } 7875 7876 virtual Representation RequiredInputRepresentation(int index) { 7877 return Representation::Tagged(); 7878 } 7879 7880 virtual OStream& PrintDataTo(OStream& os) const; // NOLINT 7881 7882 DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext) 7883 7884 private: 7885 HAllocateBlockContext(HValue* context, 7886 HValue* function, 7887 Handle<ScopeInfo> scope_info) 7888 : scope_info_(scope_info) { 7889 SetOperandAt(0, context); 7890 SetOperandAt(1, function); 7891 set_representation(Representation::Tagged()); 7892 } 7893 7894 Handle<ScopeInfo> scope_info_; 7895 }; 7896 7897 7898 7899 #undef DECLARE_INSTRUCTION 7900 #undef DECLARE_CONCRETE_INSTRUCTION 7901 7902 } } // namespace v8::internal 7903 7904 #endif // V8_HYDROGEN_INSTRUCTIONS_H_ 7905
