src/x87/lithium-x87.h - Issue 1405363003: Move Hydrogen and Lithium to src/crankshaft/

Side by Side Diff: src/x87/lithium-x87.h

Issue 1405363003: Move Hydrogen and Lithium to src/crankshaft/ (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master

Patch Set: rebased Created 5 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
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_X87_LITHIUM_X87_H_

6 #define V8_X87_LITHIUM_X87_H_

7

8 #include "src/hydrogen.h"

9 #include "src/lithium.h"

10 #include "src/lithium-allocator.h"

11 #include "src/safepoint-table.h"

12 #include "src/utils.h"

13

14 namespace v8 {

15 namespace internal {

16

17 namespace compiler {

18 class RCodeVisualizer;

19 }

20

21 // Forward declarations.

22 class LCodeGen;

23

24 #define LITHIUM_CONCRETE_INSTRUCTION_LIST(V) \

25 V(AccessArgumentsAt) \

26 V(AddI) \

27 V(AllocateBlockContext) \

28 V(Allocate) \

29 V(ApplyArguments) \

30 V(ArgumentsElements) \

31 V(ArgumentsLength) \

32 V(ArithmeticD) \

33 V(ArithmeticT) \

34 V(BitI) \

35 V(BoundsCheck) \

36 V(Branch) \

37 V(CallJSFunction) \

38 V(CallWithDescriptor) \

39 V(CallFunction) \

40 V(CallNew) \

41 V(CallNewArray) \

42 V(CallRuntime) \

43 V(CallStub) \

44 V(CheckArrayBufferNotNeutered) \

45 V(CheckInstanceType) \

46 V(CheckMaps) \

47 V(CheckMapValue) \

48 V(CheckNonSmi) \

49 V(CheckSmi) \

50 V(CheckValue) \

51 V(ClampDToUint8) \

52 V(ClampIToUint8) \

53 V(ClampTToUint8NoSSE2) \

54 V(ClassOfTestAndBranch) \

55 V(ClobberDoubles) \

56 V(CompareMinusZeroAndBranch) \

57 V(CompareNumericAndBranch) \

58 V(CmpObjectEqAndBranch) \

59 V(CmpHoleAndBranch) \

60 V(CmpMapAndBranch) \

61 V(CmpT) \

62 V(ConstantD) \

63 V(ConstantE) \

64 V(ConstantI) \

65 V(ConstantS) \

66 V(ConstantT) \

67 V(ConstructDouble) \

68 V(Context) \

69 V(DateField) \

70 V(DebugBreak) \

71 V(DeclareGlobals) \

72 V(Deoptimize) \

73 V(DivByConstI) \

74 V(DivByPowerOf2I) \

75 V(DivI) \

76 V(DoubleBits) \

77 V(DoubleToI) \

78 V(DoubleToSmi) \

79 V(Drop) \

80 V(Dummy) \

81 V(DummyUse) \

82 V(FlooringDivByConstI) \

83 V(FlooringDivByPowerOf2I) \

84 V(FlooringDivI) \

85 V(ForInCacheArray) \

86 V(ForInPrepareMap) \

87 V(GetCachedArrayIndex) \

88 V(Goto) \

89 V(HasCachedArrayIndexAndBranch) \

90 V(HasInPrototypeChainAndBranch) \

91 V(HasInstanceTypeAndBranch) \

92 V(InnerAllocatedObject) \

93 V(InstanceOf) \

94 V(InstructionGap) \

95 V(Integer32ToDouble) \

96 V(InvokeFunction) \

97 V(IsConstructCallAndBranch) \

98 V(IsStringAndBranch) \

99 V(IsSmiAndBranch) \

100 V(IsUndetectableAndBranch) \

101 V(Label) \

102 V(LazyBailout) \

103 V(LoadContextSlot) \

104 V(LoadFieldByIndex) \

105 V(LoadFunctionPrototype) \

106 V(LoadGlobalGeneric) \

107 V(LoadGlobalViaContext) \

108 V(LoadKeyed) \

109 V(LoadKeyedGeneric) \

110 V(LoadNamedField) \

111 V(LoadNamedGeneric) \

112 V(LoadRoot) \

113 V(MapEnumLength) \

114 V(MathAbs) \

115 V(MathClz32) \

116 V(MathExp) \

117 V(MathFloor) \

118 V(MathFround) \

119 V(MathLog) \

120 V(MathMinMax) \

121 V(MathPowHalf) \

122 V(MathRound) \

123 V(MathSqrt) \

124 V(MaybeGrowElements) \

125 V(ModByConstI) \

126 V(ModByPowerOf2I) \

127 V(ModI) \

128 V(MulI) \

129 V(NumberTagD) \

130 V(NumberTagI) \

131 V(NumberTagU) \

132 V(NumberUntagD) \

133 V(OsrEntry) \

134 V(Parameter) \

135 V(Power) \

136 V(Prologue) \

137 V(PushArgument) \

138 V(RegExpLiteral) \

139 V(Return) \

140 V(SeqStringGetChar) \

141 V(SeqStringSetChar) \

142 V(ShiftI) \

143 V(SmiTag) \

144 V(SmiUntag) \

145 V(StackCheck) \

146 V(StoreCodeEntry) \

147 V(StoreContextSlot) \

148 V(StoreFrameContext) \

149 V(StoreGlobalViaContext) \

150 V(StoreKeyed) \

151 V(StoreKeyedGeneric) \

152 V(StoreNamedField) \

153 V(StoreNamedGeneric) \

154 V(StringAdd) \

155 V(StringCharCodeAt) \

156 V(StringCharFromCode) \

157 V(StringCompareAndBranch) \

158 V(SubI) \

159 V(TaggedToI) \

160 V(ThisFunction) \

161 V(ToFastProperties) \

162 V(TransitionElementsKind) \

163 V(TrapAllocationMemento) \

164 V(Typeof) \

165 V(TypeofIsAndBranch) \

166 V(Uint32ToDouble) \

167 V(UnknownOSRValue) \

168 V(WrapReceiver)

169

170

171 #define DECLARE_CONCRETE_INSTRUCTION(type, mnemonic) \

172 Opcode opcode() const final { return LInstruction::k##type; } \

173 void CompileToNative(LCodeGen* generator) final; \

174 const char* Mnemonic() const final { return mnemonic; } \

175 static L##type* cast(LInstruction* instr) { \

176 DCHECK(instr->Is##type()); \

177 return reinterpret_cast<L##type*>(instr); \

178 }

179

180

181 #define DECLARE_HYDROGEN_ACCESSOR(type) \

182 H##type* hydrogen() const { \

183 return H##type::cast(hydrogen_value()); \

184 }

185

186

187 class LInstruction : public ZoneObject {

188 public:

189 LInstruction()

190 : environment_(NULL),

191 hydrogen_value_(NULL),

192 bit_field_(IsCallBits::encode(false)) {

193 }

194

195 virtual ~LInstruction() {}

196

197 virtual void CompileToNative(LCodeGen* generator) = 0;

198 virtual const char* Mnemonic() const = 0;

199 virtual void PrintTo(StringStream* stream);

200 virtual void PrintDataTo(StringStream* stream);

201 virtual void PrintOutputOperandTo(StringStream* stream);

202

203 enum Opcode {

204 // Declare a unique enum value for each instruction.

205 #define DECLARE_OPCODE(type) k##type,

206 LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE) kAdapter,

207 kNumberOfInstructions

208 #undef DECLARE_OPCODE

209 };

210

211 virtual Opcode opcode() const = 0;

212

213 // Declare non-virtual type testers for all leaf IR classes.

214 #define DECLARE_PREDICATE(type) \

215 bool Is##type() const { return opcode() == k##type; }

216 LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)

217 #undef DECLARE_PREDICATE

218

219 // Declare virtual predicates for instructions that don't have

220 // an opcode.

221 virtual bool IsGap() const { return false; }

222

223 virtual bool IsControl() const { return false; }

224

225 // Try deleting this instruction if possible.

226 virtual bool TryDelete() { return false; }

227

228 void set_environment(LEnvironment* env) { environment_ = env; }

229 LEnvironment* environment() const { return environment_; }

230 bool HasEnvironment() const { return environment_ != NULL; }

231

232 void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }

233 LPointerMap* pointer_map() const { return pointer_map_.get(); }

234 bool HasPointerMap() const { return pointer_map_.is_set(); }

235

236 void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }

237 HValue* hydrogen_value() const { return hydrogen_value_; }

238

239 void MarkAsCall() { bit_field_ = IsCallBits::update(bit_field_, true); }

240 bool IsCall() const { return IsCallBits::decode(bit_field_); }

241

242 // Interface to the register allocator and iterators.

243 bool ClobbersTemps() const { return IsCall(); }

244 bool ClobbersRegisters() const { return IsCall(); }

245 virtual bool ClobbersDoubleRegisters(Isolate* isolate) const {

246 return IsCall() \|\|

247 // We only have rudimentary X87Stack tracking, thus in general

248 // cannot handle phi-nodes.

249 (IsControl());

250 }

251

252 virtual bool HasResult() const = 0;

253 virtual LOperand* result() const = 0;

254

255 bool HasDoubleRegisterResult();

256 bool HasDoubleRegisterInput();

257 bool IsDoubleInput(X87Register reg, LCodeGen* cgen);

258

259 LOperand* FirstInput() { return InputAt(0); }

260 LOperand* Output() { return HasResult() ? result() : NULL; }

261

262 virtual bool HasInterestingComment(LCodeGen* gen) const { return true; }

263

264 #ifdef DEBUG

265 void VerifyCall();

266 #endif

267

268 virtual int InputCount() = 0;

269 virtual LOperand* InputAt(int i) = 0;

270

271 private:

272 // Iterator support.

273 friend class InputIterator;

274

275 friend class TempIterator;

276 virtual int TempCount() = 0;

277 virtual LOperand* TempAt(int i) = 0;

278

279 class IsCallBits: public BitField<bool, 0, 1> {};

280

281 LEnvironment* environment_;

282 SetOncePointer<LPointerMap> pointer_map_;

283 HValue* hydrogen_value_;

284 int bit_field_;

285 };

286

287

288 // R = number of result operands (0 or 1).

289 template<int R>

290 class LTemplateResultInstruction : public LInstruction {

291 public:

292 // Allow 0 or 1 output operands.

293 STATIC_ASSERT(R == 0 \|\| R == 1);

294 bool HasResult() const final { return R != 0 && result() != NULL; }

295 void set_result(LOperand* operand) { results_[0] = operand; }

296 LOperand* result() const override { return results_[0]; }

297

298 protected:

299 EmbeddedContainer<LOperand*, R> results_;

300 };

301

302

303 // R = number of result operands (0 or 1).

304 // I = number of input operands.

305 // T = number of temporary operands.

306 template<int R, int I, int T>

307 class LTemplateInstruction : public LTemplateResultInstruction<R> {

308 protected:

309 EmbeddedContainer<LOperand*, I> inputs_;

310 EmbeddedContainer<LOperand*, T> temps_;

311

312 private:

313 // Iterator support.

314 int InputCount() final { return I; }

315 LOperand* InputAt(int i) final { return inputs_[i]; }

316

317 int TempCount() final { return T; }

318 LOperand* TempAt(int i) final { return temps_[i]; }

319 };

320

321

322 class LGap : public LTemplateInstruction<0, 0, 0> {

323 public:

324 explicit LGap(HBasicBlock* block) : block_(block) {

325 parallel_moves_[BEFORE] = NULL;

326 parallel_moves_[START] = NULL;

327 parallel_moves_[END] = NULL;

328 parallel_moves_[AFTER] = NULL;

329 }

330

331 // Can't use the DECLARE-macro here because of sub-classes.

332 bool IsGap() const final { return true; }

333 void PrintDataTo(StringStream* stream) override;

334 static LGap* cast(LInstruction* instr) {

335 DCHECK(instr->IsGap());

336 return reinterpret_cast<LGap*>(instr);

337 }

338

339 bool IsRedundant() const;

340

341 HBasicBlock* block() const { return block_; }

342

343 enum InnerPosition {

344 BEFORE,

345 START,

346 END,

347 AFTER,

348 FIRST_INNER_POSITION = BEFORE,

349 LAST_INNER_POSITION = AFTER

350 };

351

352 LParallelMove* GetOrCreateParallelMove(InnerPosition pos, Zone* zone) {

353 if (parallel_moves_[pos] == NULL) {

354 parallel_moves_[pos] = new(zone) LParallelMove(zone);

355 }

356 return parallel_moves_[pos];

357 }

358

359 LParallelMove* GetParallelMove(InnerPosition pos) {

360 return parallel_moves_[pos];

361 }

362

363 private:

364 LParallelMove* parallel_moves_[LAST_INNER_POSITION + 1];

365 HBasicBlock* block_;

366 };

367

368

369 class LInstructionGap final : public LGap {

370 public:

371 explicit LInstructionGap(HBasicBlock* block) : LGap(block) { }

372

373 bool HasInterestingComment(LCodeGen* gen) const override {

374 return !IsRedundant();

375 }

376

377 DECLARE_CONCRETE_INSTRUCTION(InstructionGap, "gap")

378 };

379

380

381 class LClobberDoubles final : public LTemplateInstruction<0, 0, 0> {

382 public:

383 explicit LClobberDoubles(Isolate* isolate) { }

384

385 bool ClobbersDoubleRegisters(Isolate* isolate) const override { return true; }

386

387 DECLARE_CONCRETE_INSTRUCTION(ClobberDoubles, "clobber-d")

388 };

389

390

391 class LGoto final : public LTemplateInstruction<0, 0, 0> {

392 public:

393 explicit LGoto(HBasicBlock* block) : block_(block) { }

394

395 bool HasInterestingComment(LCodeGen* gen) const override;

396 DECLARE_CONCRETE_INSTRUCTION(Goto, "goto")

397 void PrintDataTo(StringStream* stream) override;

398 bool IsControl() const override { return true; }

399

400 int block_id() const { return block_->block_id(); }

401 bool ClobbersDoubleRegisters(Isolate* isolate) const override {

402 return false;

403 }

404

405 bool jumps_to_join() const { return block_->predecessors()->length() > 1; }

406 HBasicBlock* block() const { return block_; }

407

408 private:

409 HBasicBlock* block_;

410 };

411

412

413 class LPrologue final : public LTemplateInstruction<0, 0, 0> {

414 public:

415 DECLARE_CONCRETE_INSTRUCTION(Prologue, "prologue")

416 };

417

418

419 class LLazyBailout final : public LTemplateInstruction<0, 0, 0> {

420 public:

421 DECLARE_CONCRETE_INSTRUCTION(LazyBailout, "lazy-bailout")

422 };

423

424

425 class LDummy final : public LTemplateInstruction<1, 0, 0> {

426 public:

427 LDummy() {}

428 DECLARE_CONCRETE_INSTRUCTION(Dummy, "dummy")

429 };

430

431

432 class LDummyUse final : public LTemplateInstruction<1, 1, 0> {

433 public:

434 explicit LDummyUse(LOperand* value) {

435 inputs_[0] = value;

436 }

437 DECLARE_CONCRETE_INSTRUCTION(DummyUse, "dummy-use")

438 };

439

440

441 class LDeoptimize final : public LTemplateInstruction<0, 0, 0> {

442 public:

443 bool IsControl() const override { return true; }

444 DECLARE_CONCRETE_INSTRUCTION(Deoptimize, "deoptimize")

445 DECLARE_HYDROGEN_ACCESSOR(Deoptimize)

446 };

447

448

449 class LLabel final : public LGap {

450 public:

451 explicit LLabel(HBasicBlock* block)

452 : LGap(block), replacement_(NULL) { }

453

454 bool HasInterestingComment(LCodeGen* gen) const override { return false; }

455 DECLARE_CONCRETE_INSTRUCTION(Label, "label")

456

457 void PrintDataTo(StringStream* stream) override;

458

459 int block_id() const { return block()->block_id(); }

460 bool is_loop_header() const { return block()->IsLoopHeader(); }

461 bool is_osr_entry() const { return block()->is_osr_entry(); }

462 Label* label() { return &label_; }

463 LLabel* replacement() const { return replacement_; }

464 void set_replacement(LLabel* label) { replacement_ = label; }

465 bool HasReplacement() const { return replacement_ != NULL; }

466

467 private:

468 Label label_;

469 LLabel* replacement_;

470 };

471

472

473 class LParameter final : public LTemplateInstruction<1, 0, 0> {

474 public:

475 bool HasInterestingComment(LCodeGen* gen) const override { return false; }

476 DECLARE_CONCRETE_INSTRUCTION(Parameter, "parameter")

477 };

478

479

480 class LCallStub final : public LTemplateInstruction<1, 1, 0> {

481 public:

482 explicit LCallStub(LOperand* context) {

483 inputs_[0] = context;

484 }

485

486 LOperand* context() { return inputs_[0]; }

487

488 DECLARE_CONCRETE_INSTRUCTION(CallStub, "call-stub")

489 DECLARE_HYDROGEN_ACCESSOR(CallStub)

490 };

491

492

493 class LUnknownOSRValue final : public LTemplateInstruction<1, 0, 0> {

494 public:

495 bool HasInterestingComment(LCodeGen* gen) const override { return false; }

496 DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue, "unknown-osr-value")

497 };

498

499

500 template<int I, int T>

501 class LControlInstruction: public LTemplateInstruction<0, I, T> {

502 public:

503 LControlInstruction() : false_label_(NULL), true_label_(NULL) { }

504

505 bool IsControl() const final { return true; }

506

507 int SuccessorCount() { return hydrogen()->SuccessorCount(); }

508 HBasicBlock* SuccessorAt(int i) { return hydrogen()->SuccessorAt(i); }

509

510 int TrueDestination(LChunk* chunk) {

511 return chunk->LookupDestination(true_block_id());

512 }

513 int FalseDestination(LChunk* chunk) {

514 return chunk->LookupDestination(false_block_id());

515 }

516

517 Label* TrueLabel(LChunk* chunk) {

518 if (true_label_ == NULL) {

519 true_label_ = chunk->GetAssemblyLabel(TrueDestination(chunk));

520 }

521 return true_label_;

522 }

523 Label* FalseLabel(LChunk* chunk) {

524 if (false_label_ == NULL) {

525 false_label_ = chunk->GetAssemblyLabel(FalseDestination(chunk));

526 }

527 return false_label_;

528 }

529

530 protected:

531 int true_block_id() { return SuccessorAt(0)->block_id(); }

532 int false_block_id() { return SuccessorAt(1)->block_id(); }

533

534 private:

535 HControlInstruction* hydrogen() {

536 return HControlInstruction::cast(this->hydrogen_value());

537 }

538

539 Label* false_label_;

540 Label* true_label_;

541 };

542

543

544 class LWrapReceiver final : public LTemplateInstruction<1, 2, 1> {

545 public:

546 LWrapReceiver(LOperand* receiver,

547 LOperand* function,

548 LOperand* temp) {

549 inputs_[0] = receiver;

550 inputs_[1] = function;

551 temps_[0] = temp;

552 }

553

554 LOperand* receiver() { return inputs_[0]; }

555 LOperand* function() { return inputs_[1]; }

556 LOperand* temp() { return temps_[0]; }

557

558 DECLARE_CONCRETE_INSTRUCTION(WrapReceiver, "wrap-receiver")

559 DECLARE_HYDROGEN_ACCESSOR(WrapReceiver)

560 };

561

562

563 class LApplyArguments final : public LTemplateInstruction<1, 4, 0> {

564 public:

565 LApplyArguments(LOperand* function,

566 LOperand* receiver,

567 LOperand* length,

568 LOperand* elements) {

569 inputs_[0] = function;

570 inputs_[1] = receiver;

571 inputs_[2] = length;

572 inputs_[3] = elements;

573 }

574

575 LOperand* function() { return inputs_[0]; }

576 LOperand* receiver() { return inputs_[1]; }

577 LOperand* length() { return inputs_[2]; }

578 LOperand* elements() { return inputs_[3]; }

579

580 DECLARE_CONCRETE_INSTRUCTION(ApplyArguments, "apply-arguments")

581 };

582

583

584 class LAccessArgumentsAt final : public LTemplateInstruction<1, 3, 0> {

585 public:

586 LAccessArgumentsAt(LOperand* arguments, LOperand* length, LOperand* index) {

587 inputs_[0] = arguments;

588 inputs_[1] = length;

589 inputs_[2] = index;

590 }

591

592 LOperand* arguments() { return inputs_[0]; }

593 LOperand* length() { return inputs_[1]; }

594 LOperand* index() { return inputs_[2]; }

595

596 DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt, "access-arguments-at")

597

598 void PrintDataTo(StringStream* stream) override;

599 };

600

601

602 class LArgumentsLength final : public LTemplateInstruction<1, 1, 0> {

603 public:

604 explicit LArgumentsLength(LOperand* elements) {

605 inputs_[0] = elements;

606 }

607

608 LOperand* elements() { return inputs_[0]; }

609

610 DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength, "arguments-length")

611 };

612

613

614 class LArgumentsElements final : public LTemplateInstruction<1, 0, 0> {

615 public:

616 DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements, "arguments-elements")

617 DECLARE_HYDROGEN_ACCESSOR(ArgumentsElements)

618 };

619

620

621 class LDebugBreak final : public LTemplateInstruction<0, 0, 0> {

622 public:

623 DECLARE_CONCRETE_INSTRUCTION(DebugBreak, "break")

624 };

625

626

627 class LModByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {

628 public:

629 LModByPowerOf2I(LOperand* dividend, int32_t divisor) {

630 inputs_[0] = dividend;

631 divisor_ = divisor;

632 }

633

634 LOperand* dividend() { return inputs_[0]; }

635 int32_t divisor() const { return divisor_; }

636

637 DECLARE_CONCRETE_INSTRUCTION(ModByPowerOf2I, "mod-by-power-of-2-i")

638 DECLARE_HYDROGEN_ACCESSOR(Mod)

639

640 private:

641 int32_t divisor_;

642 };

643

644

645 class LModByConstI final : public LTemplateInstruction<1, 1, 2> {

646 public:

647 LModByConstI(LOperand* dividend,

648 int32_t divisor,

649 LOperand* temp1,

650 LOperand* temp2) {

651 inputs_[0] = dividend;

652 divisor_ = divisor;

653 temps_[0] = temp1;

654 temps_[1] = temp2;

655 }

656

657 LOperand* dividend() { return inputs_[0]; }

658 int32_t divisor() const { return divisor_; }

659 LOperand* temp1() { return temps_[0]; }

660 LOperand* temp2() { return temps_[1]; }

661

662 DECLARE_CONCRETE_INSTRUCTION(ModByConstI, "mod-by-const-i")

663 DECLARE_HYDROGEN_ACCESSOR(Mod)

664

665 private:

666 int32_t divisor_;

667 };

668

669

670 class LModI final : public LTemplateInstruction<1, 2, 1> {

671 public:

672 LModI(LOperand* left, LOperand* right, LOperand* temp) {

673 inputs_[0] = left;

674 inputs_[1] = right;

675 temps_[0] = temp;

676 }

677

678 LOperand* left() { return inputs_[0]; }

679 LOperand* right() { return inputs_[1]; }

680 LOperand* temp() { return temps_[0]; }

681

682 DECLARE_CONCRETE_INSTRUCTION(ModI, "mod-i")

683 DECLARE_HYDROGEN_ACCESSOR(Mod)

684 };

685

686

687 class LDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {

688 public:

689 LDivByPowerOf2I(LOperand* dividend, int32_t divisor) {

690 inputs_[0] = dividend;

691 divisor_ = divisor;

692 }

693

694 LOperand* dividend() { return inputs_[0]; }

695 int32_t divisor() const { return divisor_; }

696

697 DECLARE_CONCRETE_INSTRUCTION(DivByPowerOf2I, "div-by-power-of-2-i")

698 DECLARE_HYDROGEN_ACCESSOR(Div)

699

700 private:

701 int32_t divisor_;

702 };

703

704

705 class LDivByConstI final : public LTemplateInstruction<1, 1, 2> {

706 public:

707 LDivByConstI(LOperand* dividend,

708 int32_t divisor,

709 LOperand* temp1,

710 LOperand* temp2) {

711 inputs_[0] = dividend;

712 divisor_ = divisor;

713 temps_[0] = temp1;

714 temps_[1] = temp2;

715 }

716

717 LOperand* dividend() { return inputs_[0]; }

718 int32_t divisor() const { return divisor_; }

719 LOperand* temp1() { return temps_[0]; }

720 LOperand* temp2() { return temps_[1]; }

721

722 DECLARE_CONCRETE_INSTRUCTION(DivByConstI, "div-by-const-i")

723 DECLARE_HYDROGEN_ACCESSOR(Div)

724

725 private:

726 int32_t divisor_;

727 };

728

729

730 class LDivI final : public LTemplateInstruction<1, 2, 1> {

731 public:

732 LDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {

733 inputs_[0] = dividend;

734 inputs_[1] = divisor;

735 temps_[0] = temp;

736 }

737

738 LOperand* dividend() { return inputs_[0]; }

739 LOperand* divisor() { return inputs_[1]; }

740 LOperand* temp() { return temps_[0]; }

741

742 DECLARE_CONCRETE_INSTRUCTION(DivI, "div-i")

743 DECLARE_HYDROGEN_ACCESSOR(BinaryOperation)

744 };

745

746

747 class LFlooringDivByPowerOf2I final : public LTemplateInstruction<1, 1, 0> {

748 public:

749 LFlooringDivByPowerOf2I(LOperand* dividend, int32_t divisor) {

750 inputs_[0] = dividend;

751 divisor_ = divisor;

752 }

753

754 LOperand* dividend() { return inputs_[0]; }

755 int32_t divisor() const { return divisor_; }

756

757 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByPowerOf2I,

758 "flooring-div-by-power-of-2-i")

759 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)

760

761 private:

762 int32_t divisor_;

763 };

764

765

766 class LFlooringDivByConstI final : public LTemplateInstruction<1, 1, 3> {

767 public:

768 LFlooringDivByConstI(LOperand* dividend,

769 int32_t divisor,

770 LOperand* temp1,

771 LOperand* temp2,

772 LOperand* temp3) {

773 inputs_[0] = dividend;

774 divisor_ = divisor;

775 temps_[0] = temp1;

776 temps_[1] = temp2;

777 temps_[2] = temp3;

778 }

779

780 LOperand* dividend() { return inputs_[0]; }

781 int32_t divisor() const { return divisor_; }

782 LOperand* temp1() { return temps_[0]; }

783 LOperand* temp2() { return temps_[1]; }

784 LOperand* temp3() { return temps_[2]; }

785

786 DECLARE_CONCRETE_INSTRUCTION(FlooringDivByConstI, "flooring-div-by-const-i")

787 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)

788

789 private:

790 int32_t divisor_;

791 };

792

793

794 class LFlooringDivI final : public LTemplateInstruction<1, 2, 1> {

795 public:

796 LFlooringDivI(LOperand* dividend, LOperand* divisor, LOperand* temp) {

797 inputs_[0] = dividend;

798 inputs_[1] = divisor;

799 temps_[0] = temp;

800 }

801

802 LOperand* dividend() { return inputs_[0]; }

803 LOperand* divisor() { return inputs_[1]; }

804 LOperand* temp() { return temps_[0]; }

805

806 DECLARE_CONCRETE_INSTRUCTION(FlooringDivI, "flooring-div-i")

807 DECLARE_HYDROGEN_ACCESSOR(MathFloorOfDiv)

808 };

809

810

811 class LMulI final : public LTemplateInstruction<1, 2, 1> {

812 public:

813 LMulI(LOperand* left, LOperand* right, LOperand* temp) {

814 inputs_[0] = left;

815 inputs_[1] = right;

816 temps_[0] = temp;

817 }

818

819 LOperand* left() { return inputs_[0]; }

820 LOperand* right() { return inputs_[1]; }

821 LOperand* temp() { return temps_[0]; }

822

823 DECLARE_CONCRETE_INSTRUCTION(MulI, "mul-i")

824 DECLARE_HYDROGEN_ACCESSOR(Mul)

825 };

826

827

828 class LCompareNumericAndBranch final : public LControlInstruction<2, 0> {

829 public:

830 LCompareNumericAndBranch(LOperand* left, LOperand* right) {

831 inputs_[0] = left;

832 inputs_[1] = right;

833 }

834

835 LOperand* left() { return inputs_[0]; }

836 LOperand* right() { return inputs_[1]; }

837

838 DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch,

839 "compare-numeric-and-branch")

840 DECLARE_HYDROGEN_ACCESSOR(CompareNumericAndBranch)

841

842 Token::Value op() const { return hydrogen()->token(); }

843 bool is_double() const {

844 return hydrogen()->representation().IsDouble();

845 }

846

847 void PrintDataTo(StringStream* stream) override;

848 };

849

850

851 class LMathFloor final : public LTemplateInstruction<1, 1, 0> {

852 public:

853 explicit LMathFloor(LOperand* value) {

854 inputs_[0] = value;

855 }

856

857 LOperand* value() { return inputs_[0]; }

858

859 DECLARE_CONCRETE_INSTRUCTION(MathFloor, "math-floor")

860 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

861 };

862

863

864 class LMathRound final : public LTemplateInstruction<1, 1, 0> {

865 public:

866 explicit LMathRound(LOperand* value) {

867 inputs_[0] = value;

868 }

869

870 LOperand* value() { return inputs_[0]; }

871

872 DECLARE_CONCRETE_INSTRUCTION(MathRound, "math-round")

873 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

874 };

875

876

877 class LMathFround final : public LTemplateInstruction<1, 1, 0> {

878 public:

879 explicit LMathFround(LOperand* value) { inputs_[0] = value; }

880

881 LOperand* value() { return inputs_[0]; }

882

883 DECLARE_CONCRETE_INSTRUCTION(MathFround, "math-fround")

884 };

885

886

887 class LMathAbs final : public LTemplateInstruction<1, 2, 0> {

888 public:

889 LMathAbs(LOperand* context, LOperand* value) {

890 inputs_[1] = context;

891 inputs_[0] = value;

892 }

893

894 LOperand* context() { return inputs_[1]; }

895 LOperand* value() { return inputs_[0]; }

896

897 DECLARE_CONCRETE_INSTRUCTION(MathAbs, "math-abs")

898 DECLARE_HYDROGEN_ACCESSOR(UnaryMathOperation)

899 };

900

901

902 class LMathLog final : public LTemplateInstruction<1, 1, 0> {

903 public:

904 explicit LMathLog(LOperand* value) {

905 inputs_[0] = value;

906 }

907

908 LOperand* value() { return inputs_[0]; }

909

910 DECLARE_CONCRETE_INSTRUCTION(MathLog, "math-log")

911 };

912

913

914 class LMathClz32 final : public LTemplateInstruction<1, 1, 0> {

915 public:

916 explicit LMathClz32(LOperand* value) {

917 inputs_[0] = value;

918 }

919

920 LOperand* value() { return inputs_[0]; }

921

922 DECLARE_CONCRETE_INSTRUCTION(MathClz32, "math-clz32")

923 };

924

925

926 class LMathExp final : public LTemplateInstruction<1, 1, 2> {

927 public:

928 LMathExp(LOperand* value,

929 LOperand* temp1,

930 LOperand* temp2) {

931 inputs_[0] = value;

932 temps_[0] = temp1;

933 temps_[1] = temp2;

934 ExternalReference::InitializeMathExpData();

935 }

936

937 LOperand* value() { return inputs_[0]; }

938 LOperand* temp1() { return temps_[0]; }

939 LOperand* temp2() { return temps_[1]; }

940

941 DECLARE_CONCRETE_INSTRUCTION(MathExp, "math-exp")

942 };

943

944

945 class LMathSqrt final : public LTemplateInstruction<1, 1, 2> {

946 public:

947 explicit LMathSqrt(LOperand* value,

948 LOperand* temp1,

949 LOperand* temp2) {

950 inputs_[0] = value;

951 temps_[0] = temp1;

952 temps_[1] = temp2;

953 }

954

955 LOperand* value() { return inputs_[0]; }

956 LOperand* temp1() { return temps_[0]; }

957 LOperand* temp2() { return temps_[1]; }

958

959 DECLARE_CONCRETE_INSTRUCTION(MathSqrt, "math-sqrt")

960 };

961

962

963 class LMathPowHalf final : public LTemplateInstruction<1, 1, 0> {

964 public:

965 explicit LMathPowHalf(LOperand* value) { inputs_[0] = value; }

966

967 LOperand* value() { return inputs_[0]; }

968

969 DECLARE_CONCRETE_INSTRUCTION(MathPowHalf, "math-pow-half")

970 };

971

972

973 class LCmpObjectEqAndBranch final : public LControlInstruction<2, 0> {

974 public:

975 LCmpObjectEqAndBranch(LOperand* left, LOperand* right) {

976 inputs_[0] = left;

977 inputs_[1] = right;

978 }

979

980 LOperand* left() { return inputs_[0]; }

981 LOperand* right() { return inputs_[1]; }

982

983 DECLARE_CONCRETE_INSTRUCTION(CmpObjectEqAndBranch, "cmp-object-eq-and-branch")

984 };

985

986

987 class LCmpHoleAndBranch final : public LControlInstruction<1, 0> {

988 public:

989 explicit LCmpHoleAndBranch(LOperand* object) {

990 inputs_[0] = object;

991 }

992

993 LOperand* object() { return inputs_[0]; }

994

995 DECLARE_CONCRETE_INSTRUCTION(CmpHoleAndBranch, "cmp-hole-and-branch")

996 DECLARE_HYDROGEN_ACCESSOR(CompareHoleAndBranch)

997 };

998

999

1000 class LCompareMinusZeroAndBranch final : public LControlInstruction<1, 0> {

1001 public:

1002 explicit LCompareMinusZeroAndBranch(LOperand* value) { inputs_[0] = value; }

1003

1004 LOperand* value() { return inputs_[0]; }

1005

1006 DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch,

1007 "cmp-minus-zero-and-branch")

1008 DECLARE_HYDROGEN_ACCESSOR(CompareMinusZeroAndBranch)

1009 };

1010

1011

1012 class LIsStringAndBranch final : public LControlInstruction<1, 1> {

1013 public:

1014 LIsStringAndBranch(LOperand* value, LOperand* temp) {

1015 inputs_[0] = value;

1016 temps_[0] = temp;

1017 }

1018

1019 LOperand* value() { return inputs_[0]; }

1020 LOperand* temp() { return temps_[0]; }

1021

1022 DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch, "is-string-and-branch")

1023 DECLARE_HYDROGEN_ACCESSOR(IsStringAndBranch)

1024

1025 void PrintDataTo(StringStream* stream) override;

1026 };

1027

1028

1029 class LIsSmiAndBranch final : public LControlInstruction<1, 0> {

1030 public:

1031 explicit LIsSmiAndBranch(LOperand* value) {

1032 inputs_[0] = value;

1033 }

1034

1035 LOperand* value() { return inputs_[0]; }

1036

1037 DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch, "is-smi-and-branch")

1038 DECLARE_HYDROGEN_ACCESSOR(IsSmiAndBranch)

1039

1040 void PrintDataTo(StringStream* stream) override;

1041 };

1042

1043

1044 class LIsUndetectableAndBranch final : public LControlInstruction<1, 1> {

1045 public:

1046 LIsUndetectableAndBranch(LOperand* value, LOperand* temp) {

1047 inputs_[0] = value;

1048 temps_[0] = temp;

1049 }

1050

1051 LOperand* value() { return inputs_[0]; }

1052 LOperand* temp() { return temps_[0]; }

1053

1054 DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch,

1055 "is-undetectable-and-branch")

1056 DECLARE_HYDROGEN_ACCESSOR(IsUndetectableAndBranch)

1057

1058 void PrintDataTo(StringStream* stream) override;

1059 };

1060

1061

1062 class LStringCompareAndBranch final : public LControlInstruction<3, 0> {

1063 public:

1064 LStringCompareAndBranch(LOperand* context, LOperand* left, LOperand* right) {

1065 inputs_[0] = context;

1066 inputs_[1] = left;

1067 inputs_[2] = right;

1068 }

1069

1070 LOperand* context() { return inputs_[0]; }

1071 LOperand* left() { return inputs_[1]; }

1072 LOperand* right() { return inputs_[2]; }

1073

1074 DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch,

1075 "string-compare-and-branch")

1076 DECLARE_HYDROGEN_ACCESSOR(StringCompareAndBranch)

1077

1078 void PrintDataTo(StringStream* stream) override;

1079

1080 Token::Value op() const { return hydrogen()->token(); }

1081 };

1082

1083

1084 class LHasInstanceTypeAndBranch final : public LControlInstruction<1, 1> {

1085 public:

1086 LHasInstanceTypeAndBranch(LOperand* value, LOperand* temp) {

1087 inputs_[0] = value;

1088 temps_[0] = temp;

1089 }

1090

1091 LOperand* value() { return inputs_[0]; }

1092 LOperand* temp() { return temps_[0]; }

1093

1094 DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch,

1095 "has-instance-type-and-branch")

1096 DECLARE_HYDROGEN_ACCESSOR(HasInstanceTypeAndBranch)

1097

1098 void PrintDataTo(StringStream* stream) override;

1099 };

1100

1101

1102 class LGetCachedArrayIndex final : public LTemplateInstruction<1, 1, 0> {

1103 public:

1104 explicit LGetCachedArrayIndex(LOperand* value) {

1105 inputs_[0] = value;

1106 }

1107

1108 LOperand* value() { return inputs_[0]; }

1109

1110 DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex, "get-cached-array-index")

1111 DECLARE_HYDROGEN_ACCESSOR(GetCachedArrayIndex)

1112 };

1113

1114

1115 class LHasCachedArrayIndexAndBranch final : public LControlInstruction<1, 0> {

1116 public:

1117 explicit LHasCachedArrayIndexAndBranch(LOperand* value) {

1118 inputs_[0] = value;

1119 }

1120

1121 LOperand* value() { return inputs_[0]; }

1122

1123 DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch,

1124 "has-cached-array-index-and-branch")

1125

1126 void PrintDataTo(StringStream* stream) override;

1127 };

1128

1129

1130 class LIsConstructCallAndBranch final : public LControlInstruction<0, 1> {

1131 public:

1132 explicit LIsConstructCallAndBranch(LOperand* temp) {

1133 temps_[0] = temp;

1134 }

1135

1136 LOperand* temp() { return temps_[0]; }

1137

1138 DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch,

1139 "is-construct-call-and-branch")

1140 };

1141

1142

1143 class LClassOfTestAndBranch final : public LControlInstruction<1, 2> {

1144 public:

1145 LClassOfTestAndBranch(LOperand* value, LOperand* temp, LOperand* temp2) {

1146 inputs_[0] = value;

1147 temps_[0] = temp;

1148 temps_[1] = temp2;

1149 }

1150

1151 LOperand* value() { return inputs_[0]; }

1152 LOperand* temp() { return temps_[0]; }

1153 LOperand* temp2() { return temps_[1]; }

1154

1155 DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch,

1156 "class-of-test-and-branch")

1157 DECLARE_HYDROGEN_ACCESSOR(ClassOfTestAndBranch)

1158

1159 void PrintDataTo(StringStream* stream) override;

1160 };

1161

1162

1163 class LCmpT final : public LTemplateInstruction<1, 3, 0> {

1164 public:

1165 LCmpT(LOperand* context, LOperand* left, LOperand* right) {

1166 inputs_[0] = context;

1167 inputs_[1] = left;

1168 inputs_[2] = right;

1169 }

1170

1171 DECLARE_CONCRETE_INSTRUCTION(CmpT, "cmp-t")

1172 DECLARE_HYDROGEN_ACCESSOR(CompareGeneric)

1173

1174 Strength strength() { return hydrogen()->strength(); }

1175

1176 LOperand* context() { return inputs_[0]; }

1177 Token::Value op() const { return hydrogen()->token(); }

1178 };

1179

1180

1181 class LInstanceOf final : public LTemplateInstruction<1, 3, 0> {

1182 public:

1183 LInstanceOf(LOperand* context, LOperand* left, LOperand* right) {

1184 inputs_[0] = context;

1185 inputs_[1] = left;

1186 inputs_[2] = right;

1187 }

1188

1189 LOperand* context() const { return inputs_[0]; }

1190 LOperand* left() const { return inputs_[1]; }

1191 LOperand* right() const { return inputs_[2]; }

1192

1193 DECLARE_CONCRETE_INSTRUCTION(InstanceOf, "instance-of")

1194 };

1195

1196

1197 class LHasInPrototypeChainAndBranch final : public LControlInstruction<2, 1> {

1198 public:

1199 LHasInPrototypeChainAndBranch(LOperand* object, LOperand* prototype,

1200 LOperand* scratch) {

1201 inputs_[0] = object;

1202 inputs_[1] = prototype;

1203 temps_[0] = scratch;

1204 }

1205

1206 LOperand* object() const { return inputs_[0]; }

1207 LOperand* prototype() const { return inputs_[1]; }

1208 LOperand* scratch() const { return temps_[0]; }

1209

1210 DECLARE_CONCRETE_INSTRUCTION(HasInPrototypeChainAndBranch,

1211 "has-in-prototype-chain-and-branch")

1212 DECLARE_HYDROGEN_ACCESSOR(HasInPrototypeChainAndBranch)

1213 };

1214

1215

1216 class LBoundsCheck final : public LTemplateInstruction<0, 2, 0> {

1217 public:

1218 LBoundsCheck(LOperand* index, LOperand* length) {

1219 inputs_[0] = index;

1220 inputs_[1] = length;

1221 }

1222

1223 LOperand* index() { return inputs_[0]; }

1224 LOperand* length() { return inputs_[1]; }

1225

1226 DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")

1227 DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)

1228 };

1229

1230

1231 class LBitI final : public LTemplateInstruction<1, 2, 0> {

1232 public:

1233 LBitI(LOperand* left, LOperand* right) {

1234 inputs_[0] = left;

1235 inputs_[1] = right;

1236 }

1237

1238 LOperand* left() { return inputs_[0]; }

1239 LOperand* right() { return inputs_[1]; }

1240

1241 DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i")

1242 DECLARE_HYDROGEN_ACCESSOR(Bitwise)

1243

1244 Token::Value op() const { return hydrogen()->op(); }

1245 };

1246

1247

1248 class LShiftI final : public LTemplateInstruction<1, 2, 0> {

1249 public:

1250 LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)

1251 : op_(op), can_deopt_(can_deopt) {

1252 inputs_[0] = left;

1253 inputs_[1] = right;

1254 }

1255

1256 LOperand* left() { return inputs_[0]; }

1257 LOperand* right() { return inputs_[1]; }

1258

1259 DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i")

1260

1261 Token::Value op() const { return op_; }

1262 bool can_deopt() const { return can_deopt_; }

1263

1264 private:

1265 Token::Value op_;

1266 bool can_deopt_;

1267 };

1268

1269

1270 class LSubI final : public LTemplateInstruction<1, 2, 0> {

1271 public:

1272 LSubI(LOperand* left, LOperand* right) {

1273 inputs_[0] = left;

1274 inputs_[1] = right;

1275 }

1276

1277 LOperand* left() { return inputs_[0]; }

1278 LOperand* right() { return inputs_[1]; }

1279

1280 DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")

1281 DECLARE_HYDROGEN_ACCESSOR(Sub)

1282 };

1283

1284

1285 class LConstantI final : public LTemplateInstruction<1, 0, 0> {

1286 public:

1287 DECLARE_CONCRETE_INSTRUCTION(ConstantI, "constant-i")

1288 DECLARE_HYDROGEN_ACCESSOR(Constant)

1289

1290 int32_t value() const { return hydrogen()->Integer32Value(); }

1291 };

1292

1293

1294 class LConstantS final : public LTemplateInstruction<1, 0, 0> {

1295 public:

1296 DECLARE_CONCRETE_INSTRUCTION(ConstantS, "constant-s")

1297 DECLARE_HYDROGEN_ACCESSOR(Constant)

1298

1299 Smi* value() const { return Smi::FromInt(hydrogen()->Integer32Value()); }

1300 };

1301

1302

1303 class LConstantD final : public LTemplateInstruction<1, 0, 1> {

1304 public:

1305 DECLARE_CONCRETE_INSTRUCTION(ConstantD, "constant-d")

1306 DECLARE_HYDROGEN_ACCESSOR(Constant)

1307

1308 uint64_t bits() const { return hydrogen()->DoubleValueAsBits(); }

1309 };

1310

1311

1312 class LConstantE final : public LTemplateInstruction<1, 0, 0> {

1313 public:

1314 DECLARE_CONCRETE_INSTRUCTION(ConstantE, "constant-e")

1315 DECLARE_HYDROGEN_ACCESSOR(Constant)

1316

1317 ExternalReference value() const {

1318 return hydrogen()->ExternalReferenceValue();

1319 }

1320 };

1321

1322

1323 class LConstantT final : public LTemplateInstruction<1, 0, 0> {

1324 public:

1325 DECLARE_CONCRETE_INSTRUCTION(ConstantT, "constant-t")

1326 DECLARE_HYDROGEN_ACCESSOR(Constant)

1327

1328 Handle<Object> value(Isolate* isolate) const {

1329 return hydrogen()->handle(isolate);

1330 }

1331 };

1332

1333

1334 class LBranch final : public LControlInstruction<1, 1> {

1335 public:

1336 LBranch(LOperand* value, LOperand* temp) {

1337 inputs_[0] = value;

1338 temps_[0] = temp;

1339 }

1340

1341 LOperand* value() { return inputs_[0]; }

1342 LOperand* temp() { return temps_[0]; }

1343

1344 DECLARE_CONCRETE_INSTRUCTION(Branch, "branch")

1345 DECLARE_HYDROGEN_ACCESSOR(Branch)

1346

1347 void PrintDataTo(StringStream* stream) override;

1348 };

1349

1350

1351 class LCmpMapAndBranch final : public LControlInstruction<1, 0> {

1352 public:

1353 explicit LCmpMapAndBranch(LOperand* value) {

1354 inputs_[0] = value;

1355 }

1356

1357 LOperand* value() { return inputs_[0]; }

1358

1359 DECLARE_CONCRETE_INSTRUCTION(CmpMapAndBranch, "cmp-map-and-branch")

1360 DECLARE_HYDROGEN_ACCESSOR(CompareMap)

1361

1362 Handle<Map> map() const { return hydrogen()->map().handle(); }

1363 };

1364

1365

1366 class LMapEnumLength final : public LTemplateInstruction<1, 1, 0> {

1367 public:

1368 explicit LMapEnumLength(LOperand* value) {

1369 inputs_[0] = value;

1370 }

1371

1372 LOperand* value() { return inputs_[0]; }

1373

1374 DECLARE_CONCRETE_INSTRUCTION(MapEnumLength, "map-enum-length")

1375 };

1376

1377

1378 class LDateField final : public LTemplateInstruction<1, 1, 1> {

1379 public:

1380 LDateField(LOperand* date, LOperand* temp, Smi* index)

1381 : index_(index) {

1382 inputs_[0] = date;

1383 temps_[0] = temp;

1384 }

1385

1386 LOperand* date() { return inputs_[0]; }

1387 LOperand* temp() { return temps_[0]; }

1388

1389 DECLARE_CONCRETE_INSTRUCTION(DateField, "date-field")

1390 DECLARE_HYDROGEN_ACCESSOR(DateField)

1391

1392 Smi* index() const { return index_; }

1393

1394 private:

1395 Smi* index_;

1396 };

1397

1398

1399 class LSeqStringGetChar final : public LTemplateInstruction<1, 2, 0> {

1400 public:

1401 LSeqStringGetChar(LOperand* string, LOperand* index) {

1402 inputs_[0] = string;

1403 inputs_[1] = index;

1404 }

1405

1406 LOperand* string() const { return inputs_[0]; }

1407 LOperand* index() const { return inputs_[1]; }

1408

1409 DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar, "seq-string-get-char")

1410 DECLARE_HYDROGEN_ACCESSOR(SeqStringGetChar)

1411 };

1412

1413

1414 class LSeqStringSetChar final : public LTemplateInstruction<1, 4, 0> {

1415 public:

1416 LSeqStringSetChar(LOperand* context,

1417 LOperand* string,

1418 LOperand* index,

1419 LOperand* value) {

1420 inputs_[0] = context;

1421 inputs_[1] = string;

1422 inputs_[2] = index;

1423 inputs_[3] = value;

1424 }

1425

1426 LOperand* string() { return inputs_[1]; }

1427 LOperand* index() { return inputs_[2]; }

1428 LOperand* value() { return inputs_[3]; }

1429

1430 DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char")

1431 DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar)

1432 };

1433

1434

1435 class LAddI final : public LTemplateInstruction<1, 2, 0> {

1436 public:

1437 LAddI(LOperand* left, LOperand* right) {

1438 inputs_[0] = left;

1439 inputs_[1] = right;

1440 }

1441

1442 LOperand* left() { return inputs_[0]; }

1443 LOperand* right() { return inputs_[1]; }

1444

1445 static bool UseLea(HAdd* add) {

1446 return !add->CheckFlag(HValue::kCanOverflow) &&

1447 add->BetterLeftOperand()->UseCount() > 1;

1448 }

1449

1450 DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i")

1451 DECLARE_HYDROGEN_ACCESSOR(Add)

1452 };

1453

1454

1455 class LMathMinMax final : public LTemplateInstruction<1, 2, 1> {

1456 public:

1457 LMathMinMax(LOperand* left, LOperand* right, LOperand* temp) {

1458 inputs_[0] = left;

1459 inputs_[1] = right;

1460 temps_[0] = temp;

1461 }

1462

1463 LOperand* left() { return inputs_[0]; }

1464 LOperand* right() { return inputs_[1]; }

1465 LOperand* temp() { return temps_[0]; }

1466

1467 DECLARE_CONCRETE_INSTRUCTION(MathMinMax, "math-min-max")

1468 DECLARE_HYDROGEN_ACCESSOR(MathMinMax)

1469 };

1470

1471

1472 class LPower final : public LTemplateInstruction<1, 2, 0> {

1473 public:

1474 LPower(LOperand* left, LOperand* right) {

1475 inputs_[0] = left;

1476 inputs_[1] = right;

1477 }

1478

1479 LOperand* left() { return inputs_[0]; }

1480 LOperand* right() { return inputs_[1]; }

1481

1482 DECLARE_CONCRETE_INSTRUCTION(Power, "power")

1483 DECLARE_HYDROGEN_ACCESSOR(Power)

1484 };

1485

1486

1487 class LArithmeticD final : public LTemplateInstruction<1, 2, 0> {

1488 public:

1489 LArithmeticD(Token::Value op, LOperand* left, LOperand* right)

1490 : op_(op) {

1491 inputs_[0] = left;

1492 inputs_[1] = right;

1493 }

1494

1495 LOperand* left() { return inputs_[0]; }

1496 LOperand* right() { return inputs_[1]; }

1497

1498 Token::Value op() const { return op_; }

1499

1500 Opcode opcode() const override { return LInstruction::kArithmeticD; }

1501 void CompileToNative(LCodeGen* generator) override;

1502 const char* Mnemonic() const override;

1503

1504 private:

1505 Token::Value op_;

1506 };

1507

1508

1509 class LArithmeticT final : public LTemplateInstruction<1, 3, 0> {

1510 public:

1511 LArithmeticT(Token::Value op,

1512 LOperand* context,

1513 LOperand* left,

1514 LOperand* right)

1515 : op_(op) {

1516 inputs_[0] = context;

1517 inputs_[1] = left;

1518 inputs_[2] = right;

1519 }

1520

1521 LOperand* context() { return inputs_[0]; }

1522 LOperand* left() { return inputs_[1]; }

1523 LOperand* right() { return inputs_[2]; }

1524 Token::Value op() const { return op_; }

1525

1526 Opcode opcode() const override { return LInstruction::kArithmeticT; }

1527 void CompileToNative(LCodeGen* generator) override;

1528 const char* Mnemonic() const override;

1529

1530 DECLARE_HYDROGEN_ACCESSOR(BinaryOperation)

1531

1532 Strength strength() { return hydrogen()->strength(); }

1533

1534 private:

1535 Token::Value op_;

1536 };

1537

1538

1539 class LReturn final : public LTemplateInstruction<0, 3, 0> {

1540 public:

1541 explicit LReturn(LOperand* value,

1542 LOperand* context,

1543 LOperand* parameter_count) {

1544 inputs_[0] = value;

1545 inputs_[1] = context;

1546 inputs_[2] = parameter_count;

1547 }

1548

1549 bool has_constant_parameter_count() {

1550 return parameter_count()->IsConstantOperand();

1551 }

1552 LConstantOperand* constant_parameter_count() {

1553 DCHECK(has_constant_parameter_count());

1554 return LConstantOperand::cast(parameter_count());

1555 }

1556 LOperand* parameter_count() { return inputs_[2]; }

1557

1558 DECLARE_CONCRETE_INSTRUCTION(Return, "return")

1559 DECLARE_HYDROGEN_ACCESSOR(Return)

1560 };

1561

1562

1563 class LLoadNamedField final : public LTemplateInstruction<1, 1, 0> {

1564 public:

1565 explicit LLoadNamedField(LOperand* object) {

1566 inputs_[0] = object;

1567 }

1568

1569 LOperand* object() { return inputs_[0]; }

1570

1571 DECLARE_CONCRETE_INSTRUCTION(LoadNamedField, "load-named-field")

1572 DECLARE_HYDROGEN_ACCESSOR(LoadNamedField)

1573 };

1574

1575

1576 class LLoadNamedGeneric final : public LTemplateInstruction<1, 2, 1> {

1577 public:

1578 LLoadNamedGeneric(LOperand* context, LOperand* object, LOperand* vector) {

1579 inputs_[0] = context;

1580 inputs_[1] = object;

1581 temps_[0] = vector;

1582 }

1583

1584 LOperand* context() { return inputs_[0]; }

1585 LOperand* object() { return inputs_[1]; }

1586 LOperand* temp_vector() { return temps_[0]; }

1587

1588 DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric, "load-named-generic")

1589 DECLARE_HYDROGEN_ACCESSOR(LoadNamedGeneric)

1590

1591 Handle<Object> name() const { return hydrogen()->name(); }

1592 };

1593

1594

1595 class LLoadFunctionPrototype final : public LTemplateInstruction<1, 1, 1> {

1596 public:

1597 LLoadFunctionPrototype(LOperand* function, LOperand* temp) {

1598 inputs_[0] = function;

1599 temps_[0] = temp;

1600 }

1601

1602 LOperand* function() { return inputs_[0]; }

1603 LOperand* temp() { return temps_[0]; }

1604

1605 DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype, "load-function-prototype")

1606 DECLARE_HYDROGEN_ACCESSOR(LoadFunctionPrototype)

1607 };

1608

1609

1610 class LLoadRoot final : public LTemplateInstruction<1, 0, 0> {

1611 public:

1612 DECLARE_CONCRETE_INSTRUCTION(LoadRoot, "load-root")

1613 DECLARE_HYDROGEN_ACCESSOR(LoadRoot)

1614

1615 Heap::RootListIndex index() const { return hydrogen()->index(); }

1616 };

1617

1618

1619 class LLoadKeyed final : public LTemplateInstruction<1, 2, 0> {

1620 public:

1621 LLoadKeyed(LOperand* elements, LOperand* key) {

1622 inputs_[0] = elements;

1623 inputs_[1] = key;

1624 }

1625 LOperand* elements() { return inputs_[0]; }

1626 LOperand* key() { return inputs_[1]; }

1627 ElementsKind elements_kind() const {

1628 return hydrogen()->elements_kind();

1629 }

1630 bool is_fixed_typed_array() const {

1631 return hydrogen()->is_fixed_typed_array();

1632 }

1633

1634 DECLARE_CONCRETE_INSTRUCTION(LoadKeyed, "load-keyed")

1635 DECLARE_HYDROGEN_ACCESSOR(LoadKeyed)

1636

1637 void PrintDataTo(StringStream* stream) override;

1638 uint32_t base_offset() const { return hydrogen()->base_offset(); }

1639 bool key_is_smi() {

1640 return hydrogen()->key()->representation().IsTagged();

1641 }

1642 };

1643

1644

1645 inline static bool ExternalArrayOpRequiresTemp(

1646 Representation key_representation,

1647 ElementsKind elements_kind) {

1648 // Operations that require the key to be divided by two to be converted into

1649 // an index cannot fold the scale operation into a load and need an extra

1650 // temp register to do the work.

1651 return key_representation.IsSmi() &&

1652 (elements_kind == UINT8_ELEMENTS \|\| elements_kind == INT8_ELEMENTS \|\|

1653 elements_kind == UINT8_CLAMPED_ELEMENTS);

1654 }

1655

1656

1657 class LLoadKeyedGeneric final : public LTemplateInstruction<1, 3, 1> {

1658 public:

1659 LLoadKeyedGeneric(LOperand* context, LOperand* obj, LOperand* key,

1660 LOperand* vector) {

1661 inputs_[0] = context;

1662 inputs_[1] = obj;

1663 inputs_[2] = key;

1664 temps_[0] = vector;

1665 }

1666

1667 LOperand* context() { return inputs_[0]; }

1668 LOperand* object() { return inputs_[1]; }

1669 LOperand* key() { return inputs_[2]; }

1670 LOperand* temp_vector() { return temps_[0]; }

1671

1672 DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric, "load-keyed-generic")

1673 DECLARE_HYDROGEN_ACCESSOR(LoadKeyedGeneric)

1674 };

1675

1676

1677 class LLoadGlobalGeneric final : public LTemplateInstruction<1, 2, 1> {

1678 public:

1679 LLoadGlobalGeneric(LOperand* context, LOperand* global_object,

1680 LOperand* vector) {

1681 inputs_[0] = context;

1682 inputs_[1] = global_object;

1683 temps_[0] = vector;

1684 }

1685

1686 LOperand* context() { return inputs_[0]; }

1687 LOperand* global_object() { return inputs_[1]; }

1688 LOperand* temp_vector() { return temps_[0]; }

1689

1690 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric, "load-global-generic")

1691 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalGeneric)

1692

1693 Handle<Object> name() const { return hydrogen()->name(); }

1694 TypeofMode typeof_mode() const { return hydrogen()->typeof_mode(); }

1695 };

1696

1697

1698 class LLoadGlobalViaContext final : public LTemplateInstruction<1, 1, 1> {

1699 public:

1700 explicit LLoadGlobalViaContext(LOperand* context) { inputs_[0] = context; }

1701

1702 DECLARE_CONCRETE_INSTRUCTION(LoadGlobalViaContext, "load-global-via-context")

1703 DECLARE_HYDROGEN_ACCESSOR(LoadGlobalViaContext)

1704

1705 void PrintDataTo(StringStream* stream) override;

1706

1707 LOperand* context() { return inputs_[0]; }

1708

1709 int depth() const { return hydrogen()->depth(); }

1710 int slot_index() const { return hydrogen()->slot_index(); }

1711 };

1712

1713

1714 class LLoadContextSlot final : public LTemplateInstruction<1, 1, 0> {

1715 public:

1716 explicit LLoadContextSlot(LOperand* context) {

1717 inputs_[0] = context;

1718 }

1719

1720 LOperand* context() { return inputs_[0]; }

1721

1722 DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load-context-slot")

1723 DECLARE_HYDROGEN_ACCESSOR(LoadContextSlot)

1724

1725 int slot_index() { return hydrogen()->slot_index(); }

1726

1727 void PrintDataTo(StringStream* stream) override;

1728 };

1729

1730

1731 class LStoreContextSlot final : public LTemplateInstruction<0, 2, 1> {

1732 public:

1733 LStoreContextSlot(LOperand* context, LOperand* value, LOperand* temp) {

1734 inputs_[0] = context;

1735 inputs_[1] = value;

1736 temps_[0] = temp;

1737 }

1738

1739 LOperand* context() { return inputs_[0]; }

1740 LOperand* value() { return inputs_[1]; }

1741 LOperand* temp() { return temps_[0]; }

1742

1743 DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot, "store-context-slot")

1744 DECLARE_HYDROGEN_ACCESSOR(StoreContextSlot)

1745

1746 int slot_index() { return hydrogen()->slot_index(); }

1747

1748 void PrintDataTo(StringStream* stream) override;

1749 };

1750

1751

1752 class LPushArgument final : public LTemplateInstruction<0, 1, 0> {

1753 public:

1754 explicit LPushArgument(LOperand* value) {

1755 inputs_[0] = value;

1756 }

1757

1758 LOperand* value() { return inputs_[0]; }

1759

1760 DECLARE_CONCRETE_INSTRUCTION(PushArgument, "push-argument")

1761 };

1762

1763

1764 class LDrop final : public LTemplateInstruction<0, 0, 0> {

1765 public:

1766 explicit LDrop(int count) : count_(count) { }

1767

1768 int count() const { return count_; }

1769

1770 DECLARE_CONCRETE_INSTRUCTION(Drop, "drop")

1771

1772 private:

1773 int count_;

1774 };

1775

1776

1777 class LStoreCodeEntry final : public LTemplateInstruction<0, 2, 0> {

1778 public:

1779 LStoreCodeEntry(LOperand* function, LOperand* code_object) {

1780 inputs_[0] = function;

1781 inputs_[1] = code_object;

1782 }

1783

1784 LOperand* function() { return inputs_[0]; }

1785 LOperand* code_object() { return inputs_[1]; }

1786

1787 void PrintDataTo(StringStream* stream) override;

1788

1789 DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry, "store-code-entry")

1790 DECLARE_HYDROGEN_ACCESSOR(StoreCodeEntry)

1791 };

1792

1793

1794 class LInnerAllocatedObject final : public LTemplateInstruction<1, 2, 0> {

1795 public:

1796 LInnerAllocatedObject(LOperand* base_object, LOperand* offset) {

1797 inputs_[0] = base_object;

1798 inputs_[1] = offset;

1799 }

1800

1801 LOperand* base_object() const { return inputs_[0]; }

1802 LOperand* offset() const { return inputs_[1]; }

1803

1804 void PrintDataTo(StringStream* stream) override;

1805

1806 DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject, "inner-allocated-object")

1807 };

1808

1809

1810 class LThisFunction final : public LTemplateInstruction<1, 0, 0> {

1811 public:

1812 DECLARE_CONCRETE_INSTRUCTION(ThisFunction, "this-function")

1813 DECLARE_HYDROGEN_ACCESSOR(ThisFunction)

1814 };

1815

1816

1817 class LContext final : public LTemplateInstruction<1, 0, 0> {

1818 public:

1819 DECLARE_CONCRETE_INSTRUCTION(Context, "context")

1820 DECLARE_HYDROGEN_ACCESSOR(Context)

1821 };

1822

1823

1824 class LDeclareGlobals final : public LTemplateInstruction<0, 1, 0> {

1825 public:

1826 explicit LDeclareGlobals(LOperand* context) {

1827 inputs_[0] = context;

1828 }

1829

1830 LOperand* context() { return inputs_[0]; }

1831

1832 DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals, "declare-globals")

1833 DECLARE_HYDROGEN_ACCESSOR(DeclareGlobals)

1834 };

1835

1836

1837 class LCallJSFunction final : public LTemplateInstruction<1, 1, 0> {

1838 public:

1839 explicit LCallJSFunction(LOperand* function) {

1840 inputs_[0] = function;

1841 }

1842

1843 LOperand* function() { return inputs_[0]; }

1844

1845 DECLARE_CONCRETE_INSTRUCTION(CallJSFunction, "call-js-function")

1846 DECLARE_HYDROGEN_ACCESSOR(CallJSFunction)

1847

1848 void PrintDataTo(StringStream* stream) override;

1849

1850 int arity() const { return hydrogen()->argument_count() - 1; }

1851 };

1852

1853

1854 class LCallWithDescriptor final : public LTemplateResultInstruction<1> {

1855 public:

1856 LCallWithDescriptor(CallInterfaceDescriptor descriptor,

1857 const ZoneList<LOperand>& operands, Zone zone)

1858 : inputs_(descriptor.GetRegisterParameterCount() +

1859 kImplicitRegisterParameterCount,

1860 zone) {

1861 DCHECK(descriptor.GetRegisterParameterCount() +

1862 kImplicitRegisterParameterCount ==

1863 operands.length());

1864 inputs_.AddAll(operands, zone);

1865 }

1866

1867 LOperand* target() const { return inputs_[0]; }

1868

1869 DECLARE_HYDROGEN_ACCESSOR(CallWithDescriptor)

1870

1871 // The target and context are passed as implicit parameters that are not

1872 // explicitly listed in the descriptor.

1873 static const int kImplicitRegisterParameterCount = 2;

1874

1875 private:

1876 DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor, "call-with-descriptor")

1877

1878 void PrintDataTo(StringStream* stream) override;

1879

1880 int arity() const { return hydrogen()->argument_count() - 1; }

1881

1882 ZoneList<LOperand*> inputs_;

1883

1884 // Iterator support.

1885 int InputCount() final { return inputs_.length(); }

1886 LOperand* InputAt(int i) final { return inputs_[i]; }

1887

1888 int TempCount() final { return 0; }

1889 LOperand* TempAt(int i) final { return NULL; }

1890 };

1891

1892

1893 class LInvokeFunction final : public LTemplateInstruction<1, 2, 0> {

1894 public:

1895 LInvokeFunction(LOperand* context, LOperand* function) {

1896 inputs_[0] = context;

1897 inputs_[1] = function;

1898 }

1899

1900 LOperand* context() { return inputs_[0]; }

1901 LOperand* function() { return inputs_[1]; }

1902

1903 DECLARE_CONCRETE_INSTRUCTION(InvokeFunction, "invoke-function")

1904 DECLARE_HYDROGEN_ACCESSOR(InvokeFunction)

1905

1906 void PrintDataTo(StringStream* stream) override;

1907

1908 int arity() const { return hydrogen()->argument_count() - 1; }

1909 };

1910

1911

1912 class LCallFunction final : public LTemplateInstruction<1, 2, 2> {

1913 public:

1914 LCallFunction(LOperand* context, LOperand* function, LOperand* slot,

1915 LOperand* vector) {

1916 inputs_[0] = context;

1917 inputs_[1] = function;

1918 temps_[0] = slot;

1919 temps_[1] = vector;

1920 }

1921

1922 LOperand* context() { return inputs_[0]; }

1923 LOperand* function() { return inputs_[1]; }

1924 LOperand* temp_slot() { return temps_[0]; }

1925 LOperand* temp_vector() { return temps_[1]; }

1926

1927 DECLARE_CONCRETE_INSTRUCTION(CallFunction, "call-function")

1928 DECLARE_HYDROGEN_ACCESSOR(CallFunction)

1929

1930 void PrintDataTo(StringStream* stream) override;

1931 int arity() const { return hydrogen()->argument_count() - 1; }

1932 };

1933

1934

1935 class LCallNew final : public LTemplateInstruction<1, 2, 0> {

1936 public:

1937 LCallNew(LOperand* context, LOperand* constructor) {

1938 inputs_[0] = context;

1939 inputs_[1] = constructor;

1940 }

1941

1942 LOperand* context() { return inputs_[0]; }

1943 LOperand* constructor() { return inputs_[1]; }

1944

1945 DECLARE_CONCRETE_INSTRUCTION(CallNew, "call-new")

1946 DECLARE_HYDROGEN_ACCESSOR(CallNew)

1947

1948 void PrintDataTo(StringStream* stream) override;

1949

1950 int arity() const { return hydrogen()->argument_count() - 1; }

1951 };

1952

1953

1954 class LCallNewArray final : public LTemplateInstruction<1, 2, 0> {

1955 public:

1956 LCallNewArray(LOperand* context, LOperand* constructor) {

1957 inputs_[0] = context;

1958 inputs_[1] = constructor;

1959 }

1960

1961 LOperand* context() { return inputs_[0]; }

1962 LOperand* constructor() { return inputs_[1]; }

1963

1964 DECLARE_CONCRETE_INSTRUCTION(CallNewArray, "call-new-array")

1965 DECLARE_HYDROGEN_ACCESSOR(CallNewArray)

1966

1967 void PrintDataTo(StringStream* stream) override;

1968

1969 int arity() const { return hydrogen()->argument_count() - 1; }

1970 };

1971

1972

1973 class LCallRuntime final : public LTemplateInstruction<1, 1, 0> {

1974 public:

1975 explicit LCallRuntime(LOperand* context) {

1976 inputs_[0] = context;

1977 }

1978

1979 LOperand* context() { return inputs_[0]; }

1980

1981 DECLARE_CONCRETE_INSTRUCTION(CallRuntime, "call-runtime")

1982 DECLARE_HYDROGEN_ACCESSOR(CallRuntime)

1983

1984 bool ClobbersDoubleRegisters(Isolate* isolate) const override {

1985 return save_doubles() == kDontSaveFPRegs;

1986 }

1987

1988 const Runtime::Function* function() const { return hydrogen()->function(); }

1989 int arity() const { return hydrogen()->argument_count(); }

1990 SaveFPRegsMode save_doubles() const { return hydrogen()->save_doubles(); }

1991 };

1992

1993

1994 class LInteger32ToDouble final : public LTemplateInstruction<1, 1, 0> {

1995 public:

1996 explicit LInteger32ToDouble(LOperand* value) {

1997 inputs_[0] = value;

1998 }

1999

2000 LOperand* value() { return inputs_[0]; }

2001

2002 DECLARE_CONCRETE_INSTRUCTION(Integer32ToDouble, "int32-to-double")

2003 };

2004

2005

2006 class LUint32ToDouble final : public LTemplateInstruction<1, 1, 1> {

2007 public:

2008 explicit LUint32ToDouble(LOperand* value) {

2009 inputs_[0] = value;

2010 }

2011

2012 LOperand* value() { return inputs_[0]; }

2013

2014 DECLARE_CONCRETE_INSTRUCTION(Uint32ToDouble, "uint32-to-double")

2015 };

2016

2017

2018 class LNumberTagI final : public LTemplateInstruction<1, 1, 1> {

2019 public:

2020 LNumberTagI(LOperand* value, LOperand* temp) {

2021 inputs_[0] = value;

2022 temps_[0] = temp;

2023 }

2024

2025 LOperand* value() { return inputs_[0]; }

2026 LOperand* temp() { return temps_[0]; }

2027

2028 DECLARE_CONCRETE_INSTRUCTION(NumberTagI, "number-tag-i")

2029 };

2030

2031

2032 class LNumberTagU final : public LTemplateInstruction<1, 1, 1> {

2033 public:

2034 LNumberTagU(LOperand* value, LOperand* temp) {

2035 inputs_[0] = value;

2036 temps_[0] = temp;

2037 }

2038

2039 LOperand* value() { return inputs_[0]; }

2040 LOperand* temp() { return temps_[0]; }

2041

2042 DECLARE_CONCRETE_INSTRUCTION(NumberTagU, "number-tag-u")

2043 };

2044

2045

2046 class LNumberTagD final : public LTemplateInstruction<1, 1, 1> {

2047 public:

2048 LNumberTagD(LOperand* value, LOperand* temp) {

2049 inputs_[0] = value;

2050 temps_[0] = temp;

2051 }

2052

2053 LOperand* value() { return inputs_[0]; }

2054 LOperand* temp() { return temps_[0]; }

2055

2056 DECLARE_CONCRETE_INSTRUCTION(NumberTagD, "number-tag-d")

2057 DECLARE_HYDROGEN_ACCESSOR(Change)

2058 };

2059

2060

2061 // Sometimes truncating conversion from a tagged value to an int32.

2062 class LDoubleToI final : public LTemplateInstruction<1, 1, 0> {

2063 public:

2064 explicit LDoubleToI(LOperand* value) {

2065 inputs_[0] = value;

2066 }

2067

2068 LOperand* value() { return inputs_[0]; }

2069

2070 DECLARE_CONCRETE_INSTRUCTION(DoubleToI, "double-to-i")

2071 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)

2072

2073 bool truncating() { return hydrogen()->CanTruncateToInt32(); }

2074 };

2075

2076

2077 class LDoubleToSmi final : public LTemplateInstruction<1, 1, 0> {

2078 public:

2079 explicit LDoubleToSmi(LOperand* value) {

2080 inputs_[0] = value;

2081 }

2082

2083 LOperand* value() { return inputs_[0]; }

2084

2085 DECLARE_CONCRETE_INSTRUCTION(DoubleToSmi, "double-to-smi")

2086 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)

2087 };

2088

2089

2090 // Truncating conversion from a tagged value to an int32.

2091 class LTaggedToI final : public LTemplateInstruction<1, 1, 0> {

2092 public:

2093 explicit LTaggedToI(LOperand* value) {

2094 inputs_[0] = value;

2095 }

2096

2097 LOperand* value() { return inputs_[0]; }

2098

2099 DECLARE_CONCRETE_INSTRUCTION(TaggedToI, "tagged-to-i")

2100 DECLARE_HYDROGEN_ACCESSOR(Change)

2101

2102 bool truncating() { return hydrogen()->CanTruncateToInt32(); }

2103 };

2104

2105

2106 class LSmiTag final : public LTemplateInstruction<1, 1, 0> {

2107 public:

2108 explicit LSmiTag(LOperand* value) {

2109 inputs_[0] = value;

2110 }

2111

2112 LOperand* value() { return inputs_[0]; }

2113

2114 DECLARE_CONCRETE_INSTRUCTION(SmiTag, "smi-tag")

2115 DECLARE_HYDROGEN_ACCESSOR(Change)

2116 };

2117

2118

2119 class LNumberUntagD final : public LTemplateInstruction<1, 1, 1> {

2120 public:

2121 explicit LNumberUntagD(LOperand* value, LOperand* temp) {

2122 inputs_[0] = value;

2123 temps_[0] = temp;

2124 }

2125

2126 LOperand* value() { return inputs_[0]; }

2127 LOperand* temp() { return temps_[0]; }

2128

2129 DECLARE_CONCRETE_INSTRUCTION(NumberUntagD, "double-untag")

2130 DECLARE_HYDROGEN_ACCESSOR(Change);

2131 };

2132

2133

2134 class LSmiUntag final : public LTemplateInstruction<1, 1, 0> {

2135 public:

2136 LSmiUntag(LOperand* value, bool needs_check)

2137 : needs_check_(needs_check) {

2138 inputs_[0] = value;

2139 }

2140

2141 LOperand* value() { return inputs_[0]; }

2142

2143 DECLARE_CONCRETE_INSTRUCTION(SmiUntag, "smi-untag")

2144

2145 bool needs_check() const { return needs_check_; }

2146

2147 private:

2148 bool needs_check_;

2149 };

2150

2151

2152 class LStoreNamedField final : public LTemplateInstruction<0, 2, 2> {

2153 public:

2154 LStoreNamedField(LOperand* obj,

2155 LOperand* val,

2156 LOperand* temp,

2157 LOperand* temp_map) {

2158 inputs_[0] = obj;

2159 inputs_[1] = val;

2160 temps_[0] = temp;

2161 temps_[1] = temp_map;

2162 }

2163

2164 LOperand* object() { return inputs_[0]; }

2165 LOperand* value() { return inputs_[1]; }

2166 LOperand* temp() { return temps_[0]; }

2167 LOperand* temp_map() { return temps_[1]; }

2168

2169 DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store-named-field")

2170 DECLARE_HYDROGEN_ACCESSOR(StoreNamedField)

2171

2172 void PrintDataTo(StringStream* stream) override;

2173 };

2174

2175

2176 class LStoreNamedGeneric final : public LTemplateInstruction<0, 3, 2> {

2177 public:

2178 LStoreNamedGeneric(LOperand* context, LOperand* object, LOperand* value,

2179 LOperand* slot, LOperand* vector) {

2180 inputs_[0] = context;

2181 inputs_[1] = object;

2182 inputs_[2] = value;

2183 temps_[0] = slot;

2184 temps_[1] = vector;

2185 }

2186

2187 LOperand* context() { return inputs_[0]; }

2188 LOperand* object() { return inputs_[1]; }

2189 LOperand* value() { return inputs_[2]; }

2190 LOperand* temp_slot() { return temps_[0]; }

2191 LOperand* temp_vector() { return temps_[1]; }

2192

2193 DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric, "store-named-generic")

2194 DECLARE_HYDROGEN_ACCESSOR(StoreNamedGeneric)

2195

2196 void PrintDataTo(StringStream* stream) override;

2197 Handle<Object> name() const { return hydrogen()->name(); }

2198 LanguageMode language_mode() { return hydrogen()->language_mode(); }

2199 };

2200

2201

2202 class LStoreGlobalViaContext final : public LTemplateInstruction<0, 2, 0> {

2203 public:

2204 LStoreGlobalViaContext(LOperand* context, LOperand* value) {

2205 inputs_[0] = context;

2206 inputs_[1] = value;

2207 }

2208

2209 LOperand* context() { return inputs_[0]; }

2210 LOperand* value() { return inputs_[1]; }

2211

2212 DECLARE_CONCRETE_INSTRUCTION(StoreGlobalViaContext,

2213 "store-global-via-context")

2214 DECLARE_HYDROGEN_ACCESSOR(StoreGlobalViaContext)

2215

2216 void PrintDataTo(StringStream* stream) override;

2217

2218 int depth() { return hydrogen()->depth(); }

2219 int slot_index() { return hydrogen()->slot_index(); }

2220 LanguageMode language_mode() { return hydrogen()->language_mode(); }

2221 };

2222

2223

2224 class LStoreKeyed final : public LTemplateInstruction<0, 3, 0> {

2225 public:

2226 LStoreKeyed(LOperand* obj, LOperand* key, LOperand* val) {

2227 inputs_[0] = obj;

2228 inputs_[1] = key;

2229 inputs_[2] = val;

2230 }

2231

2232 bool is_fixed_typed_array() const {

2233 return hydrogen()->is_fixed_typed_array();

2234 }

2235 LOperand* elements() { return inputs_[0]; }

2236 LOperand* key() { return inputs_[1]; }

2237 LOperand* value() { return inputs_[2]; }

2238 ElementsKind elements_kind() const {

2239 return hydrogen()->elements_kind();

2240 }

2241

2242 DECLARE_CONCRETE_INSTRUCTION(StoreKeyed, "store-keyed")

2243 DECLARE_HYDROGEN_ACCESSOR(StoreKeyed)

2244

2245 void PrintDataTo(StringStream* stream) override;

2246 uint32_t base_offset() const { return hydrogen()->base_offset(); }

2247 bool NeedsCanonicalization() { return hydrogen()->NeedsCanonicalization(); }

2248 };

2249

2250

2251 class LStoreKeyedGeneric final : public LTemplateInstruction<0, 4, 2> {

2252 public:

2253 LStoreKeyedGeneric(LOperand* context, LOperand* object, LOperand* key,

2254 LOperand* value, LOperand* slot, LOperand* vector) {

2255 inputs_[0] = context;

2256 inputs_[1] = object;

2257 inputs_[2] = key;

2258 inputs_[3] = value;

2259 temps_[0] = slot;

2260 temps_[1] = vector;

2261 }

2262

2263 LOperand* context() { return inputs_[0]; }

2264 LOperand* object() { return inputs_[1]; }

2265 LOperand* key() { return inputs_[2]; }

2266 LOperand* value() { return inputs_[3]; }

2267 LOperand* temp_slot() { return temps_[0]; }

2268 LOperand* temp_vector() { return temps_[1]; }

2269

2270 DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric, "store-keyed-generic")

2271 DECLARE_HYDROGEN_ACCESSOR(StoreKeyedGeneric)

2272

2273 void PrintDataTo(StringStream* stream) override;

2274

2275 LanguageMode language_mode() { return hydrogen()->language_mode(); }

2276 };

2277

2278

2279 class LTransitionElementsKind final : public LTemplateInstruction<0, 2, 2> {

2280 public:

2281 LTransitionElementsKind(LOperand* object,

2282 LOperand* context,

2283 LOperand* new_map_temp,

2284 LOperand* temp) {

2285 inputs_[0] = object;

2286 inputs_[1] = context;

2287 temps_[0] = new_map_temp;

2288 temps_[1] = temp;

2289 }

2290

2291 LOperand* context() { return inputs_[1]; }

2292 LOperand* object() { return inputs_[0]; }

2293 LOperand* new_map_temp() { return temps_[0]; }

2294 LOperand* temp() { return temps_[1]; }

2295

2296 DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind,

2297 "transition-elements-kind")

2298 DECLARE_HYDROGEN_ACCESSOR(TransitionElementsKind)

2299

2300 void PrintDataTo(StringStream* stream) override;

2301

2302 Handle<Map> original_map() { return hydrogen()->original_map().handle(); }

2303 Handle<Map> transitioned_map() {

2304 return hydrogen()->transitioned_map().handle();

2305 }

2306 ElementsKind from_kind() { return hydrogen()->from_kind(); }

2307 ElementsKind to_kind() { return hydrogen()->to_kind(); }

2308 };

2309

2310

2311 class LTrapAllocationMemento final : public LTemplateInstruction<0, 1, 1> {

2312 public:

2313 LTrapAllocationMemento(LOperand* object,

2314 LOperand* temp) {

2315 inputs_[0] = object;

2316 temps_[0] = temp;

2317 }

2318

2319 LOperand* object() { return inputs_[0]; }

2320 LOperand* temp() { return temps_[0]; }

2321

2322 DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento,

2323 "trap-allocation-memento")

2324 };

2325

2326

2327 class LMaybeGrowElements final : public LTemplateInstruction<1, 5, 0> {

2328 public:

2329 LMaybeGrowElements(LOperand* context, LOperand* object, LOperand* elements,

2330 LOperand* key, LOperand* current_capacity) {

2331 inputs_[0] = context;

2332 inputs_[1] = object;

2333 inputs_[2] = elements;

2334 inputs_[3] = key;

2335 inputs_[4] = current_capacity;

2336 }

2337

2338 LOperand* context() { return inputs_[0]; }

2339 LOperand* object() { return inputs_[1]; }

2340 LOperand* elements() { return inputs_[2]; }

2341 LOperand* key() { return inputs_[3]; }

2342 LOperand* current_capacity() { return inputs_[4]; }

2343

2344 DECLARE_HYDROGEN_ACCESSOR(MaybeGrowElements)

2345 DECLARE_CONCRETE_INSTRUCTION(MaybeGrowElements, "maybe-grow-elements")

2346 };

2347

2348

2349 class LStringAdd final : public LTemplateInstruction<1, 3, 0> {

2350 public:

2351 LStringAdd(LOperand* context, LOperand* left, LOperand* right) {

2352 inputs_[0] = context;

2353 inputs_[1] = left;

2354 inputs_[2] = right;

2355 }

2356

2357 LOperand* context() { return inputs_[0]; }

2358 LOperand* left() { return inputs_[1]; }

2359 LOperand* right() { return inputs_[2]; }

2360

2361 DECLARE_CONCRETE_INSTRUCTION(StringAdd, "string-add")

2362 DECLARE_HYDROGEN_ACCESSOR(StringAdd)

2363 };

2364

2365

2366 class LStringCharCodeAt final : public LTemplateInstruction<1, 3, 0> {

2367 public:

2368 LStringCharCodeAt(LOperand* context, LOperand* string, LOperand* index) {

2369 inputs_[0] = context;

2370 inputs_[1] = string;

2371 inputs_[2] = index;

2372 }

2373

2374 LOperand* context() { return inputs_[0]; }

2375 LOperand* string() { return inputs_[1]; }

2376 LOperand* index() { return inputs_[2]; }

2377

2378 DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt, "string-char-code-at")

2379 DECLARE_HYDROGEN_ACCESSOR(StringCharCodeAt)

2380 };

2381

2382

2383 class LStringCharFromCode final : public LTemplateInstruction<1, 2, 0> {

2384 public:

2385 LStringCharFromCode(LOperand* context, LOperand* char_code) {

2386 inputs_[0] = context;

2387 inputs_[1] = char_code;

2388 }

2389

2390 LOperand* context() { return inputs_[0]; }

2391 LOperand* char_code() { return inputs_[1]; }

2392

2393 DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode, "string-char-from-code")

2394 DECLARE_HYDROGEN_ACCESSOR(StringCharFromCode)

2395 };

2396

2397

2398 class LCheckValue final : public LTemplateInstruction<0, 1, 0> {

2399 public:

2400 explicit LCheckValue(LOperand* value) {

2401 inputs_[0] = value;

2402 }

2403

2404 LOperand* value() { return inputs_[0]; }

2405

2406 DECLARE_CONCRETE_INSTRUCTION(CheckValue, "check-value")

2407 DECLARE_HYDROGEN_ACCESSOR(CheckValue)

2408 };

2409

2410

2411 class LCheckArrayBufferNotNeutered final

2412 : public LTemplateInstruction<0, 1, 1> {

2413 public:

2414 explicit LCheckArrayBufferNotNeutered(LOperand* view, LOperand* scratch) {

2415 inputs_[0] = view;

2416 temps_[0] = scratch;

2417 }

2418

2419 LOperand* view() { return inputs_[0]; }

2420 LOperand* scratch() { return temps_[0]; }

2421

2422 DECLARE_CONCRETE_INSTRUCTION(CheckArrayBufferNotNeutered,

2423 "check-array-buffer-not-neutered")

2424 DECLARE_HYDROGEN_ACCESSOR(CheckArrayBufferNotNeutered)

2425 };

2426

2427

2428 class LCheckInstanceType final : public LTemplateInstruction<0, 1, 1> {

2429 public:

2430 LCheckInstanceType(LOperand* value, LOperand* temp) {

2431 inputs_[0] = value;

2432 temps_[0] = temp;

2433 }

2434

2435 LOperand* value() { return inputs_[0]; }

2436 LOperand* temp() { return temps_[0]; }

2437

2438 DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType, "check-instance-type")

2439 DECLARE_HYDROGEN_ACCESSOR(CheckInstanceType)

2440 };

2441

2442

2443 class LCheckMaps final : public LTemplateInstruction<0, 1, 0> {

2444 public:

2445 explicit LCheckMaps(LOperand* value = NULL) {

2446 inputs_[0] = value;

2447 }

2448

2449 LOperand* value() { return inputs_[0]; }

2450

2451 DECLARE_CONCRETE_INSTRUCTION(CheckMaps, "check-maps")

2452 DECLARE_HYDROGEN_ACCESSOR(CheckMaps)

2453 };

2454

2455

2456 class LCheckSmi final : public LTemplateInstruction<1, 1, 0> {

2457 public:

2458 explicit LCheckSmi(LOperand* value) {

2459 inputs_[0] = value;

2460 }

2461

2462 LOperand* value() { return inputs_[0]; }

2463

2464 DECLARE_CONCRETE_INSTRUCTION(CheckSmi, "check-smi")

2465 };

2466

2467

2468 class LClampDToUint8 final : public LTemplateInstruction<1, 1, 0> {

2469 public:

2470 explicit LClampDToUint8(LOperand* value) {

2471 inputs_[0] = value;

2472 }

2473

2474 LOperand* unclamped() { return inputs_[0]; }

2475

2476 DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")

2477 };

2478

2479

2480 class LClampIToUint8 final : public LTemplateInstruction<1, 1, 0> {

2481 public:

2482 explicit LClampIToUint8(LOperand* value) {

2483 inputs_[0] = value;

2484 }

2485

2486 LOperand* unclamped() { return inputs_[0]; }

2487

2488 DECLARE_CONCRETE_INSTRUCTION(ClampIToUint8, "clamp-i-to-uint8")

2489 };

2490

2491

2492 // Truncating conversion from a tagged value to an int32.

2493 class LClampTToUint8NoSSE2 final : public LTemplateInstruction<1, 1, 3> {

2494 public:

2495 LClampTToUint8NoSSE2(LOperand* unclamped,

2496 LOperand* temp1,

2497 LOperand* temp2,

2498 LOperand* temp3) {

2499 inputs_[0] = unclamped;

2500 temps_[0] = temp1;

2501 temps_[1] = temp2;

2502 temps_[2] = temp3;

2503 }

2504

2505 LOperand* unclamped() { return inputs_[0]; }

2506 LOperand* scratch() { return temps_[0]; }

2507 LOperand* scratch2() { return temps_[1]; }

2508 LOperand* scratch3() { return temps_[2]; }

2509

2510 DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8NoSSE2,

2511 "clamp-t-to-uint8-nosse2")

2512 DECLARE_HYDROGEN_ACCESSOR(UnaryOperation)

2513 };

2514

2515

2516 class LCheckNonSmi final : public LTemplateInstruction<0, 1, 0> {

2517 public:

2518 explicit LCheckNonSmi(LOperand* value) {

2519 inputs_[0] = value;

2520 }

2521

2522 LOperand* value() { return inputs_[0]; }

2523

2524 DECLARE_CONCRETE_INSTRUCTION(CheckNonSmi, "check-non-smi")

2525 DECLARE_HYDROGEN_ACCESSOR(CheckHeapObject)

2526 };

2527

2528

2529 class LDoubleBits final : public LTemplateInstruction<1, 1, 0> {

2530 public:

2531 explicit LDoubleBits(LOperand* value) {

2532 inputs_[0] = value;

2533 }

2534

2535 LOperand* value() { return inputs_[0]; }

2536

2537 DECLARE_CONCRETE_INSTRUCTION(DoubleBits, "double-bits")

2538 DECLARE_HYDROGEN_ACCESSOR(DoubleBits)

2539 };

2540

2541

2542 class LConstructDouble final : public LTemplateInstruction<1, 2, 0> {

2543 public:

2544 LConstructDouble(LOperand* hi, LOperand* lo) {

2545 inputs_[0] = hi;

2546 inputs_[1] = lo;

2547 }

2548

2549 LOperand* hi() { return inputs_[0]; }

2550 LOperand* lo() { return inputs_[1]; }

2551

2552 DECLARE_CONCRETE_INSTRUCTION(ConstructDouble, "construct-double")

2553 };

2554

2555

2556 class LAllocate final : public LTemplateInstruction<1, 2, 1> {

2557 public:

2558 LAllocate(LOperand* context, LOperand* size, LOperand* temp) {

2559 inputs_[0] = context;

2560 inputs_[1] = size;

2561 temps_[0] = temp;

2562 }

2563

2564 LOperand* context() { return inputs_[0]; }

2565 LOperand* size() { return inputs_[1]; }

2566 LOperand* temp() { return temps_[0]; }

2567

2568 DECLARE_CONCRETE_INSTRUCTION(Allocate, "allocate")

2569 DECLARE_HYDROGEN_ACCESSOR(Allocate)

2570 };

2571

2572

2573 class LRegExpLiteral final : public LTemplateInstruction<1, 1, 0> {

2574 public:

2575 explicit LRegExpLiteral(LOperand* context) {

2576 inputs_[0] = context;

2577 }

2578

2579 LOperand* context() { return inputs_[0]; }

2580

2581 DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral, "regexp-literal")

2582 DECLARE_HYDROGEN_ACCESSOR(RegExpLiteral)

2583 };

2584

2585

2586 class LToFastProperties final : public LTemplateInstruction<1, 1, 0> {

2587 public:

2588 explicit LToFastProperties(LOperand* value) {

2589 inputs_[0] = value;

2590 }

2591

2592 LOperand* value() { return inputs_[0]; }

2593

2594 DECLARE_CONCRETE_INSTRUCTION(ToFastProperties, "to-fast-properties")

2595 DECLARE_HYDROGEN_ACCESSOR(ToFastProperties)

2596 };

2597

2598

2599 class LTypeof final : public LTemplateInstruction<1, 2, 0> {

2600 public:

2601 LTypeof(LOperand* context, LOperand* value) {

2602 inputs_[0] = context;

2603 inputs_[1] = value;

2604 }

2605

2606 LOperand* context() { return inputs_[0]; }

2607 LOperand* value() { return inputs_[1]; }

2608

2609 DECLARE_CONCRETE_INSTRUCTION(Typeof, "typeof")

2610 };

2611

2612

2613 class LTypeofIsAndBranch final : public LControlInstruction<1, 0> {

2614 public:

2615 explicit LTypeofIsAndBranch(LOperand* value) {

2616 inputs_[0] = value;

2617 }

2618

2619 LOperand* value() { return inputs_[0]; }

2620

2621 DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch, "typeof-is-and-branch")

2622 DECLARE_HYDROGEN_ACCESSOR(TypeofIsAndBranch)

2623

2624 Handle<String> type_literal() { return hydrogen()->type_literal(); }

2625

2626 void PrintDataTo(StringStream* stream) override;

2627 };

2628

2629

2630 class LOsrEntry final : public LTemplateInstruction<0, 0, 0> {

2631 public:

2632 bool HasInterestingComment(LCodeGen* gen) const override { return false; }

2633 DECLARE_CONCRETE_INSTRUCTION(OsrEntry, "osr-entry")

2634 };

2635

2636

2637 class LStackCheck final : public LTemplateInstruction<0, 1, 0> {

2638 public:

2639 explicit LStackCheck(LOperand* context) {

2640 inputs_[0] = context;

2641 }

2642

2643 LOperand* context() { return inputs_[0]; }

2644

2645 DECLARE_CONCRETE_INSTRUCTION(StackCheck, "stack-check")

2646 DECLARE_HYDROGEN_ACCESSOR(StackCheck)

2647

2648 Label* done_label() { return &done_label_; }

2649

2650 private:

2651 Label done_label_;

2652 };

2653

2654

2655 class LForInPrepareMap final : public LTemplateInstruction<1, 2, 0> {

2656 public:

2657 LForInPrepareMap(LOperand* context, LOperand* object) {

2658 inputs_[0] = context;

2659 inputs_[1] = object;

2660 }

2661

2662 LOperand* context() { return inputs_[0]; }

2663 LOperand* object() { return inputs_[1]; }

2664

2665 DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap, "for-in-prepare-map")

2666 };

2667

2668

2669 class LForInCacheArray final : public LTemplateInstruction<1, 1, 0> {

2670 public:

2671 explicit LForInCacheArray(LOperand* map) {

2672 inputs_[0] = map;

2673 }

2674

2675 LOperand* map() { return inputs_[0]; }

2676

2677 DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray, "for-in-cache-array")

2678

2679 int idx() {

2680 return HForInCacheArray::cast(this->hydrogen_value())->idx();

2681 }

2682 };

2683

2684

2685 class LCheckMapValue final : public LTemplateInstruction<0, 2, 0> {

2686 public:

2687 LCheckMapValue(LOperand* value, LOperand* map) {

2688 inputs_[0] = value;

2689 inputs_[1] = map;

2690 }

2691

2692 LOperand* value() { return inputs_[0]; }

2693 LOperand* map() { return inputs_[1]; }

2694

2695 DECLARE_CONCRETE_INSTRUCTION(CheckMapValue, "check-map-value")

2696 };

2697

2698

2699 class LLoadFieldByIndex final : public LTemplateInstruction<1, 2, 0> {

2700 public:

2701 LLoadFieldByIndex(LOperand* object, LOperand* index) {

2702 inputs_[0] = object;

2703 inputs_[1] = index;

2704 }

2705

2706 LOperand* object() { return inputs_[0]; }

2707 LOperand* index() { return inputs_[1]; }

2708

2709 DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex, "load-field-by-index")

2710 };

2711

2712

2713 class LStoreFrameContext: public LTemplateInstruction<0, 1, 0> {

2714 public:

2715 explicit LStoreFrameContext(LOperand* context) {

2716 inputs_[0] = context;

2717 }

2718

2719 LOperand* context() { return inputs_[0]; }

2720

2721 DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext, "store-frame-context")

2722 };

2723

2724

2725 class LAllocateBlockContext: public LTemplateInstruction<1, 2, 0> {

2726 public:

2727 LAllocateBlockContext(LOperand* context, LOperand* function) {

2728 inputs_[0] = context;

2729 inputs_[1] = function;

2730 }

2731

2732 LOperand* context() { return inputs_[0]; }

2733 LOperand* function() { return inputs_[1]; }

2734

2735 Handle<ScopeInfo> scope_info() { return hydrogen()->scope_info(); }

2736

2737 DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext, "allocate-block-context")

2738 DECLARE_HYDROGEN_ACCESSOR(AllocateBlockContext)

2739 };

2740

2741

2742 class LChunkBuilder;

2743 class LPlatformChunk final : public LChunk {

2744 public:

2745 LPlatformChunk(CompilationInfo* info, HGraph* graph)

2746 : LChunk(info, graph),

2747 num_double_slots_(0) { }

2748

2749 int GetNextSpillIndex(RegisterKind kind);

2750 LOperand* GetNextSpillSlot(RegisterKind kind);

2751

2752 int num_double_slots() const { return num_double_slots_; }

2753

2754 private:

2755 int num_double_slots_;

2756 };

2757

2758

2759 class LChunkBuilder final : public LChunkBuilderBase {

2760 public:

2761 LChunkBuilder(CompilationInfo* info, HGraph* graph, LAllocator* allocator)

2762 : LChunkBuilderBase(info, graph),

2763 current_instruction_(NULL),

2764 current_block_(NULL),

2765 next_block_(NULL),

2766 allocator_(allocator) {}

2767

2768 // Build the sequence for the graph.

2769 LPlatformChunk* Build();

2770

2771 // Declare methods that deal with the individual node types.

2772 #define DECLARE_DO(type) LInstruction* Do##type(H##type* node);

2773 HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_DO)

2774 #undef DECLARE_DO

2775

2776 LInstruction* DoMathFloor(HUnaryMathOperation* instr);

2777 LInstruction* DoMathRound(HUnaryMathOperation* instr);

2778 LInstruction* DoMathFround(HUnaryMathOperation* instr);

2779 LInstruction* DoMathAbs(HUnaryMathOperation* instr);

2780 LInstruction* DoMathLog(HUnaryMathOperation* instr);

2781 LInstruction* DoMathExp(HUnaryMathOperation* instr);

2782 LInstruction* DoMathSqrt(HUnaryMathOperation* instr);

2783 LInstruction* DoMathPowHalf(HUnaryMathOperation* instr);

2784 LInstruction* DoMathClz32(HUnaryMathOperation* instr);

2785 LInstruction* DoDivByPowerOf2I(HDiv* instr);

2786 LInstruction* DoDivByConstI(HDiv* instr);

2787 LInstruction* DoDivI(HDiv* instr);

2788 LInstruction* DoModByPowerOf2I(HMod* instr);

2789 LInstruction* DoModByConstI(HMod* instr);

2790 LInstruction* DoModI(HMod* instr);

2791 LInstruction* DoFlooringDivByPowerOf2I(HMathFloorOfDiv* instr);

2792 LInstruction* DoFlooringDivByConstI(HMathFloorOfDiv* instr);

2793 LInstruction* DoFlooringDivI(HMathFloorOfDiv* instr);

2794

2795 private:

2796 // Methods for getting operands for Use / Define / Temp.

2797 LUnallocated* ToUnallocated(Register reg);

2798 LUnallocated* ToUnallocated(X87Register reg);

2799

2800 // Methods for setting up define-use relationships.

2801 MUST_USE_RESULT LOperand* Use(HValue* value, LUnallocated* operand);

2802 MUST_USE_RESULT LOperand* UseFixed(HValue* value, Register fixed_register);

2803

2804 // A value that is guaranteed to be allocated to a register.

2805 // Operand created by UseRegister is guaranteed to be live until the end of

2806 // instruction. This means that register allocator will not reuse it's

2807 // register for any other operand inside instruction.

2808 // Operand created by UseRegisterAtStart is guaranteed to be live only at

2809 // instruction start. Register allocator is free to assign the same register

2810 // to some other operand used inside instruction (i.e. temporary or

2811 // output).

2812 MUST_USE_RESULT LOperand* UseRegister(HValue* value);

2813 MUST_USE_RESULT LOperand* UseRegisterAtStart(HValue* value);

2814

2815 // An input operand in a register that may be trashed.

2816 MUST_USE_RESULT LOperand* UseTempRegister(HValue* value);

2817

2818 // An input operand in a register or stack slot.

2819 MUST_USE_RESULT LOperand* Use(HValue* value);

2820 MUST_USE_RESULT LOperand* UseAtStart(HValue* value);

2821

2822 // An input operand in a register, stack slot or a constant operand.

2823 MUST_USE_RESULT LOperand* UseOrConstant(HValue* value);

2824 MUST_USE_RESULT LOperand* UseOrConstantAtStart(HValue* value);

2825

2826 // An input operand in a fixed register or a constant operand.

2827 MUST_USE_RESULT LOperand* UseFixedOrConstant(HValue* value,

2828 Register fixed_register);

2829

2830 // An input operand in a register or a constant operand.

2831 MUST_USE_RESULT LOperand* UseRegisterOrConstant(HValue* value);

2832 MUST_USE_RESULT LOperand* UseRegisterOrConstantAtStart(HValue* value);

2833

2834 // An input operand in a constant operand.

2835 MUST_USE_RESULT LOperand* UseConstant(HValue* value);

2836

2837 // An input operand in register, stack slot or a constant operand.

2838 // Will not be moved to a register even if one is freely available.

2839 MUST_USE_RESULT LOperand* UseAny(HValue* value) override;

2840

2841 // Temporary operand that must be in a register.

2842 MUST_USE_RESULT LUnallocated* TempRegister();

2843 MUST_USE_RESULT LOperand* FixedTemp(Register reg);

2844

2845 // Methods for setting up define-use relationships.

2846 // Return the same instruction that they are passed.

2847 LInstruction* Define(LTemplateResultInstruction<1>* instr,

2848 LUnallocated* result);

2849 LInstruction* DefineAsRegister(LTemplateResultInstruction<1>* instr);

2850 LInstruction* DefineAsSpilled(LTemplateResultInstruction<1>* instr,

2851 int index);

2852 LInstruction* DefineSameAsFirst(LTemplateResultInstruction<1>* instr);

2853 LInstruction* DefineFixed(LTemplateResultInstruction<1>* instr,

2854 Register reg);

2855 LInstruction* DefineFixed(LTemplateResultInstruction<1>* instr,

2856 X87Register reg);

2857 LInstruction* DefineX87TOS(LTemplateResultInstruction<1>* instr);

2858 // Assigns an environment to an instruction. An instruction which can

2859 // deoptimize must have an environment.

2860 LInstruction* AssignEnvironment(LInstruction* instr);

2861 // Assigns a pointer map to an instruction. An instruction which can

2862 // trigger a GC or a lazy deoptimization must have a pointer map.

2863 LInstruction* AssignPointerMap(LInstruction* instr);

2864

2865 enum CanDeoptimize { CAN_DEOPTIMIZE_EAGERLY, CANNOT_DEOPTIMIZE_EAGERLY };

2866

2867 LOperand* GetSeqStringSetCharOperand(HSeqStringSetChar* instr);

2868

2869 // Marks a call for the register allocator. Assigns a pointer map to

2870 // support GC and lazy deoptimization. Assigns an environment to support

2871 // eager deoptimization if CAN_DEOPTIMIZE_EAGERLY.

2872 LInstruction* MarkAsCall(

2873 LInstruction* instr,

2874 HInstruction* hinstr,

2875 CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY);

2876

2877 void VisitInstruction(HInstruction* current);

2878 void AddInstruction(LInstruction* instr, HInstruction* current);

2879

2880 void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);

2881 LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr);

2882 LInstruction* DoArithmeticD(Token::Value op,

2883 HArithmeticBinaryOperation* instr);

2884 LInstruction* DoArithmeticT(Token::Value op,

2885 HBinaryOperation* instr);

2886

2887 LOperand* GetStoreKeyedValueOperand(HStoreKeyed* instr);

2888

2889 HInstruction* current_instruction_;

2890 HBasicBlock* current_block_;

2891 HBasicBlock* next_block_;

2892 LAllocator* allocator_;

2893

2894 DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);

2895 };

2896

2897 #undef DECLARE_HYDROGEN_ACCESSOR

2898 #undef DECLARE_CONCRETE_INSTRUCTION

2899

2900 } // namespace internal

2901 } // namespace v8

2902

2903 #endif // V8_X87_LITHIUM_X87_H_

OLD	NEW

« no previous file with comments | « src/x87/lithium-gap-resolver-x87.cc ('k') | src/x87/lithium-x87.cc » ('j') | no next file with comments »