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_LITHIUM_H_
6#define V8_LITHIUM_H_
7
8#include <set>
9
10#include "src/allocation.h"
11#include "src/bailout-reason.h"
12#include "src/hydrogen.h"
13#include "src/safepoint-table.h"
14#include "src/zone-allocator.h"
15
16namespace v8 {
17namespace internal {
18
19#define LITHIUM_OPERAND_LIST(V)               \
20  V(ConstantOperand, CONSTANT_OPERAND,  128)  \
21  V(StackSlot,       STACK_SLOT,        128)  \
22  V(DoubleStackSlot, DOUBLE_STACK_SLOT, 128)  \
23  V(Register,        REGISTER,          16)   \
24  V(DoubleRegister,  DOUBLE_REGISTER,   16)
25
26class LOperand : public ZoneObject {
27 public:
28  enum Kind {
29    INVALID,
30    UNALLOCATED,
31    CONSTANT_OPERAND,
32    STACK_SLOT,
33    DOUBLE_STACK_SLOT,
34    REGISTER,
35    DOUBLE_REGISTER
36  };
37
38  LOperand() : value_(KindField::encode(INVALID)) { }
39
40  Kind kind() const { return KindField::decode(value_); }
41  int index() const { return static_cast<int>(value_) >> kKindFieldWidth; }
42#define LITHIUM_OPERAND_PREDICATE(name, type, number) \
43  bool Is##name() const { return kind() == type; }
44  LITHIUM_OPERAND_LIST(LITHIUM_OPERAND_PREDICATE)
45  LITHIUM_OPERAND_PREDICATE(Unallocated, UNALLOCATED, 0)
46  LITHIUM_OPERAND_PREDICATE(Ignored, INVALID, 0)
47#undef LITHIUM_OPERAND_PREDICATE
48  bool Equals(LOperand* other) const { return value_ == other->value_; }
49
50  void PrintTo(StringStream* stream);
51  void ConvertTo(Kind kind, int index) {
52    if (kind == REGISTER) DCHECK(index >= 0);
53    value_ = KindField::encode(kind);
54    value_ |= index << kKindFieldWidth;
55    DCHECK(this->index() == index);
56  }
57
58  // Calls SetUpCache()/TearDownCache() for each subclass.
59  static void SetUpCaches();
60  static void TearDownCaches();
61
62 protected:
63  static const int kKindFieldWidth = 3;
64  class KindField : public BitField<Kind, 0, kKindFieldWidth> { };
65
66  LOperand(Kind kind, int index) { ConvertTo(kind, index); }
67
68  unsigned value_;
69};
70
71
72class LUnallocated : public LOperand {
73 public:
74  enum BasicPolicy {
75    FIXED_SLOT,
76    EXTENDED_POLICY
77  };
78
79  enum ExtendedPolicy {
80    NONE,
81    ANY,
82    FIXED_REGISTER,
83    FIXED_DOUBLE_REGISTER,
84    MUST_HAVE_REGISTER,
85    MUST_HAVE_DOUBLE_REGISTER,
86    WRITABLE_REGISTER,
87    SAME_AS_FIRST_INPUT
88  };
89
90  // Lifetime of operand inside the instruction.
91  enum Lifetime {
92    // USED_AT_START operand is guaranteed to be live only at
93    // instruction start. Register allocator is free to assign the same register
94    // to some other operand used inside instruction (i.e. temporary or
95    // output).
96    USED_AT_START,
97
98    // USED_AT_END operand is treated as live until the end of
99    // instruction. This means that register allocator will not reuse it's
100    // register for any other operand inside instruction.
101    USED_AT_END
102  };
103
104  explicit LUnallocated(ExtendedPolicy policy) : LOperand(UNALLOCATED, 0) {
105    value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
106    value_ |= ExtendedPolicyField::encode(policy);
107    value_ |= LifetimeField::encode(USED_AT_END);
108  }
109
110  LUnallocated(BasicPolicy policy, int index) : LOperand(UNALLOCATED, 0) {
111    DCHECK(policy == FIXED_SLOT);
112    value_ |= BasicPolicyField::encode(policy);
113    value_ |= index << FixedSlotIndexField::kShift;
114    DCHECK(this->fixed_slot_index() == index);
115  }
116
117  LUnallocated(ExtendedPolicy policy, int index) : LOperand(UNALLOCATED, 0) {
118    DCHECK(policy == FIXED_REGISTER || policy == FIXED_DOUBLE_REGISTER);
119    value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
120    value_ |= ExtendedPolicyField::encode(policy);
121    value_ |= LifetimeField::encode(USED_AT_END);
122    value_ |= FixedRegisterField::encode(index);
123  }
124
125  LUnallocated(ExtendedPolicy policy, Lifetime lifetime)
126      : LOperand(UNALLOCATED, 0) {
127    value_ |= BasicPolicyField::encode(EXTENDED_POLICY);
128    value_ |= ExtendedPolicyField::encode(policy);
129    value_ |= LifetimeField::encode(lifetime);
130  }
131
132  LUnallocated* CopyUnconstrained(Zone* zone) {
133    LUnallocated* result = new(zone) LUnallocated(ANY);
134    result->set_virtual_register(virtual_register());
135    return result;
136  }
137
138  static LUnallocated* cast(LOperand* op) {
139    DCHECK(op->IsUnallocated());
140    return reinterpret_cast<LUnallocated*>(op);
141  }
142
143  // The encoding used for LUnallocated operands depends on the policy that is
144  // stored within the operand. The FIXED_SLOT policy uses a compact encoding
145  // because it accommodates a larger pay-load.
146  //
147  // For FIXED_SLOT policy:
148  //     +------------------------------------------+
149  //     |       slot_index      |  vreg  | 0 | 001 |
150  //     +------------------------------------------+
151  //
152  // For all other (extended) policies:
153  //     +------------------------------------------+
154  //     |  reg_index  | L | PPP |  vreg  | 1 | 001 |    L ... Lifetime
155  //     +------------------------------------------+    P ... Policy
156  //
157  // The slot index is a signed value which requires us to decode it manually
158  // instead of using the BitField utility class.
159
160  // The superclass has a KindField.
161  STATIC_ASSERT(kKindFieldWidth == 3);
162
163  // BitFields for all unallocated operands.
164  class BasicPolicyField     : public BitField<BasicPolicy,     3,  1> {};
165  class VirtualRegisterField : public BitField<unsigned,        4, 18> {};
166
167  // BitFields specific to BasicPolicy::FIXED_SLOT.
168  class FixedSlotIndexField  : public BitField<int,            22, 10> {};
169
170  // BitFields specific to BasicPolicy::EXTENDED_POLICY.
171  class ExtendedPolicyField  : public BitField<ExtendedPolicy, 22,  3> {};
172  class LifetimeField        : public BitField<Lifetime,       25,  1> {};
173  class FixedRegisterField   : public BitField<int,            26,  6> {};
174
175  static const int kMaxVirtualRegisters = VirtualRegisterField::kMax + 1;
176  static const int kFixedSlotIndexWidth = FixedSlotIndexField::kSize;
177  static const int kMaxFixedSlotIndex = (1 << (kFixedSlotIndexWidth - 1)) - 1;
178  static const int kMinFixedSlotIndex = -(1 << (kFixedSlotIndexWidth - 1));
179
180  // Predicates for the operand policy.
181  bool HasAnyPolicy() const {
182    return basic_policy() == EXTENDED_POLICY &&
183        extended_policy() == ANY;
184  }
185  bool HasFixedPolicy() const {
186    return basic_policy() == FIXED_SLOT ||
187        extended_policy() == FIXED_REGISTER ||
188        extended_policy() == FIXED_DOUBLE_REGISTER;
189  }
190  bool HasRegisterPolicy() const {
191    return basic_policy() == EXTENDED_POLICY && (
192        extended_policy() == WRITABLE_REGISTER ||
193        extended_policy() == MUST_HAVE_REGISTER);
194  }
195  bool HasDoubleRegisterPolicy() const {
196    return basic_policy() == EXTENDED_POLICY &&
197        extended_policy() == MUST_HAVE_DOUBLE_REGISTER;
198  }
199  bool HasSameAsInputPolicy() const {
200    return basic_policy() == EXTENDED_POLICY &&
201        extended_policy() == SAME_AS_FIRST_INPUT;
202  }
203  bool HasFixedSlotPolicy() const {
204    return basic_policy() == FIXED_SLOT;
205  }
206  bool HasFixedRegisterPolicy() const {
207    return basic_policy() == EXTENDED_POLICY &&
208        extended_policy() == FIXED_REGISTER;
209  }
210  bool HasFixedDoubleRegisterPolicy() const {
211    return basic_policy() == EXTENDED_POLICY &&
212        extended_policy() == FIXED_DOUBLE_REGISTER;
213  }
214  bool HasWritableRegisterPolicy() const {
215    return basic_policy() == EXTENDED_POLICY &&
216        extended_policy() == WRITABLE_REGISTER;
217  }
218
219  // [basic_policy]: Distinguish between FIXED_SLOT and all other policies.
220  BasicPolicy basic_policy() const {
221    return BasicPolicyField::decode(value_);
222  }
223
224  // [extended_policy]: Only for non-FIXED_SLOT. The finer-grained policy.
225  ExtendedPolicy extended_policy() const {
226    DCHECK(basic_policy() == EXTENDED_POLICY);
227    return ExtendedPolicyField::decode(value_);
228  }
229
230  // [fixed_slot_index]: Only for FIXED_SLOT.
231  int fixed_slot_index() const {
232    DCHECK(HasFixedSlotPolicy());
233    return static_cast<int>(value_) >> FixedSlotIndexField::kShift;
234  }
235
236  // [fixed_register_index]: Only for FIXED_REGISTER or FIXED_DOUBLE_REGISTER.
237  int fixed_register_index() const {
238    DCHECK(HasFixedRegisterPolicy() || HasFixedDoubleRegisterPolicy());
239    return FixedRegisterField::decode(value_);
240  }
241
242  // [virtual_register]: The virtual register ID for this operand.
243  int virtual_register() const {
244    return VirtualRegisterField::decode(value_);
245  }
246  void set_virtual_register(unsigned id) {
247    value_ = VirtualRegisterField::update(value_, id);
248  }
249
250  // [lifetime]: Only for non-FIXED_SLOT.
251  bool IsUsedAtStart() {
252    DCHECK(basic_policy() == EXTENDED_POLICY);
253    return LifetimeField::decode(value_) == USED_AT_START;
254  }
255};
256
257
258class LMoveOperands FINAL BASE_EMBEDDED {
259 public:
260  LMoveOperands(LOperand* source, LOperand* destination)
261      : source_(source), destination_(destination) {
262  }
263
264  LOperand* source() const { return source_; }
265  void set_source(LOperand* operand) { source_ = operand; }
266
267  LOperand* destination() const { return destination_; }
268  void set_destination(LOperand* operand) { destination_ = operand; }
269
270  // The gap resolver marks moves as "in-progress" by clearing the
271  // destination (but not the source).
272  bool IsPending() const {
273    return destination_ == NULL && source_ != NULL;
274  }
275
276  // True if this move a move into the given destination operand.
277  bool Blocks(LOperand* operand) const {
278    return !IsEliminated() && source()->Equals(operand);
279  }
280
281  // A move is redundant if it's been eliminated, if its source and
282  // destination are the same, or if its destination is unneeded or constant.
283  bool IsRedundant() const {
284    return IsEliminated() || source_->Equals(destination_) || IsIgnored() ||
285           (destination_ != NULL && destination_->IsConstantOperand());
286  }
287
288  bool IsIgnored() const {
289    return destination_ != NULL && destination_->IsIgnored();
290  }
291
292  // We clear both operands to indicate move that's been eliminated.
293  void Eliminate() { source_ = destination_ = NULL; }
294  bool IsEliminated() const {
295    DCHECK(source_ != NULL || destination_ == NULL);
296    return source_ == NULL;
297  }
298
299 private:
300  LOperand* source_;
301  LOperand* destination_;
302};
303
304
305template<LOperand::Kind kOperandKind, int kNumCachedOperands>
306class LSubKindOperand FINAL : public LOperand {
307 public:
308  static LSubKindOperand* Create(int index, Zone* zone) {
309    DCHECK(index >= 0);
310    if (index < kNumCachedOperands) return &cache[index];
311    return new(zone) LSubKindOperand(index);
312  }
313
314  static LSubKindOperand* cast(LOperand* op) {
315    DCHECK(op->kind() == kOperandKind);
316    return reinterpret_cast<LSubKindOperand*>(op);
317  }
318
319  static void SetUpCache();
320  static void TearDownCache();
321
322 private:
323  static LSubKindOperand* cache;
324
325  LSubKindOperand() : LOperand() { }
326  explicit LSubKindOperand(int index) : LOperand(kOperandKind, index) { }
327};
328
329
330#define LITHIUM_TYPEDEF_SUBKIND_OPERAND_CLASS(name, type, number)   \
331typedef LSubKindOperand<LOperand::type, number> L##name;
332LITHIUM_OPERAND_LIST(LITHIUM_TYPEDEF_SUBKIND_OPERAND_CLASS)
333#undef LITHIUM_TYPEDEF_SUBKIND_OPERAND_CLASS
334
335
336class LParallelMove FINAL : public ZoneObject {
337 public:
338  explicit LParallelMove(Zone* zone) : move_operands_(4, zone) { }
339
340  void AddMove(LOperand* from, LOperand* to, Zone* zone) {
341    move_operands_.Add(LMoveOperands(from, to), zone);
342  }
343
344  bool IsRedundant() const;
345
346  ZoneList<LMoveOperands>* move_operands() { return &move_operands_; }
347
348  void PrintDataTo(StringStream* stream) const;
349
350 private:
351  ZoneList<LMoveOperands> move_operands_;
352};
353
354
355class LPointerMap FINAL : public ZoneObject {
356 public:
357  explicit LPointerMap(Zone* zone)
358      : pointer_operands_(8, zone),
359        untagged_operands_(0, zone),
360        lithium_position_(-1) { }
361
362  const ZoneList<LOperand*>* GetNormalizedOperands() {
363    for (int i = 0; i < untagged_operands_.length(); ++i) {
364      RemovePointer(untagged_operands_[i]);
365    }
366    untagged_operands_.Clear();
367    return &pointer_operands_;
368  }
369  int lithium_position() const { return lithium_position_; }
370
371  void set_lithium_position(int pos) {
372    DCHECK(lithium_position_ == -1);
373    lithium_position_ = pos;
374  }
375
376  void RecordPointer(LOperand* op, Zone* zone);
377  void RemovePointer(LOperand* op);
378  void RecordUntagged(LOperand* op, Zone* zone);
379  void PrintTo(StringStream* stream);
380
381 private:
382  ZoneList<LOperand*> pointer_operands_;
383  ZoneList<LOperand*> untagged_operands_;
384  int lithium_position_;
385};
386
387
388class LEnvironment FINAL : public ZoneObject {
389 public:
390  LEnvironment(Handle<JSFunction> closure,
391               FrameType frame_type,
392               BailoutId ast_id,
393               int parameter_count,
394               int argument_count,
395               int value_count,
396               LEnvironment* outer,
397               HEnterInlined* entry,
398               Zone* zone)
399      : closure_(closure),
400        frame_type_(frame_type),
401        arguments_stack_height_(argument_count),
402        deoptimization_index_(Safepoint::kNoDeoptimizationIndex),
403        translation_index_(-1),
404        ast_id_(ast_id),
405        translation_size_(value_count),
406        parameter_count_(parameter_count),
407        pc_offset_(-1),
408        values_(value_count, zone),
409        is_tagged_(value_count, zone),
410        is_uint32_(value_count, zone),
411        object_mapping_(0, zone),
412        outer_(outer),
413        entry_(entry),
414        zone_(zone),
415        has_been_used_(false) { }
416
417  Handle<JSFunction> closure() const { return closure_; }
418  FrameType frame_type() const { return frame_type_; }
419  int arguments_stack_height() const { return arguments_stack_height_; }
420  int deoptimization_index() const { return deoptimization_index_; }
421  int translation_index() const { return translation_index_; }
422  BailoutId ast_id() const { return ast_id_; }
423  int translation_size() const { return translation_size_; }
424  int parameter_count() const { return parameter_count_; }
425  int pc_offset() const { return pc_offset_; }
426  const ZoneList<LOperand*>* values() const { return &values_; }
427  LEnvironment* outer() const { return outer_; }
428  HEnterInlined* entry() { return entry_; }
429  Zone* zone() const { return zone_; }
430
431  bool has_been_used() const { return has_been_used_; }
432  void set_has_been_used() { has_been_used_ = true; }
433
434  void AddValue(LOperand* operand,
435                Representation representation,
436                bool is_uint32) {
437    values_.Add(operand, zone());
438    if (representation.IsSmiOrTagged()) {
439      DCHECK(!is_uint32);
440      is_tagged_.Add(values_.length() - 1, zone());
441    }
442
443    if (is_uint32) {
444      is_uint32_.Add(values_.length() - 1, zone());
445    }
446  }
447
448  bool HasTaggedValueAt(int index) const {
449    return is_tagged_.Contains(index);
450  }
451
452  bool HasUint32ValueAt(int index) const {
453    return is_uint32_.Contains(index);
454  }
455
456  void AddNewObject(int length, bool is_arguments) {
457    uint32_t encoded = LengthOrDupeField::encode(length) |
458                       IsArgumentsField::encode(is_arguments) |
459                       IsDuplicateField::encode(false);
460    object_mapping_.Add(encoded, zone());
461  }
462
463  void AddDuplicateObject(int dupe_of) {
464    uint32_t encoded = LengthOrDupeField::encode(dupe_of) |
465                       IsDuplicateField::encode(true);
466    object_mapping_.Add(encoded, zone());
467  }
468
469  int ObjectDuplicateOfAt(int index) {
470    DCHECK(ObjectIsDuplicateAt(index));
471    return LengthOrDupeField::decode(object_mapping_[index]);
472  }
473
474  int ObjectLengthAt(int index) {
475    DCHECK(!ObjectIsDuplicateAt(index));
476    return LengthOrDupeField::decode(object_mapping_[index]);
477  }
478
479  bool ObjectIsArgumentsAt(int index) {
480    DCHECK(!ObjectIsDuplicateAt(index));
481    return IsArgumentsField::decode(object_mapping_[index]);
482  }
483
484  bool ObjectIsDuplicateAt(int index) {
485    return IsDuplicateField::decode(object_mapping_[index]);
486  }
487
488  void Register(int deoptimization_index,
489                int translation_index,
490                int pc_offset) {
491    DCHECK(!HasBeenRegistered());
492    deoptimization_index_ = deoptimization_index;
493    translation_index_ = translation_index;
494    pc_offset_ = pc_offset;
495  }
496  bool HasBeenRegistered() const {
497    return deoptimization_index_ != Safepoint::kNoDeoptimizationIndex;
498  }
499
500  void PrintTo(StringStream* stream);
501
502  // Marker value indicating a de-materialized object.
503  static LOperand* materialization_marker() { return NULL; }
504
505  // Encoding used for the object_mapping map below.
506  class LengthOrDupeField : public BitField<int,   0, 30> { };
507  class IsArgumentsField  : public BitField<bool, 30,  1> { };
508  class IsDuplicateField  : public BitField<bool, 31,  1> { };
509
510 private:
511  Handle<JSFunction> closure_;
512  FrameType frame_type_;
513  int arguments_stack_height_;
514  int deoptimization_index_;
515  int translation_index_;
516  BailoutId ast_id_;
517  int translation_size_;
518  int parameter_count_;
519  int pc_offset_;
520
521  // Value array: [parameters] [locals] [expression stack] [de-materialized].
522  //              |>--------- translation_size ---------<|
523  ZoneList<LOperand*> values_;
524  GrowableBitVector is_tagged_;
525  GrowableBitVector is_uint32_;
526
527  // Map with encoded information about materialization_marker operands.
528  ZoneList<uint32_t> object_mapping_;
529
530  LEnvironment* outer_;
531  HEnterInlined* entry_;
532  Zone* zone_;
533  bool has_been_used_;
534};
535
536
537// Iterates over the non-null, non-constant operands in an environment.
538class ShallowIterator FINAL BASE_EMBEDDED {
539 public:
540  explicit ShallowIterator(LEnvironment* env)
541      : env_(env),
542        limit_(env != NULL ? env->values()->length() : 0),
543        current_(0) {
544    SkipUninteresting();
545  }
546
547  bool Done() { return current_ >= limit_; }
548
549  LOperand* Current() {
550    DCHECK(!Done());
551    DCHECK(env_->values()->at(current_) != NULL);
552    return env_->values()->at(current_);
553  }
554
555  void Advance() {
556    DCHECK(!Done());
557    ++current_;
558    SkipUninteresting();
559  }
560
561  LEnvironment* env() { return env_; }
562
563 private:
564  bool ShouldSkip(LOperand* op) {
565    return op == NULL || op->IsConstantOperand();
566  }
567
568  // Skip until something interesting, beginning with and including current_.
569  void SkipUninteresting() {
570    while (current_ < limit_ && ShouldSkip(env_->values()->at(current_))) {
571      ++current_;
572    }
573  }
574
575  LEnvironment* env_;
576  int limit_;
577  int current_;
578};
579
580
581// Iterator for non-null, non-constant operands incl. outer environments.
582class DeepIterator FINAL BASE_EMBEDDED {
583 public:
584  explicit DeepIterator(LEnvironment* env)
585      : current_iterator_(env) {
586    SkipUninteresting();
587  }
588
589  bool Done() { return current_iterator_.Done(); }
590
591  LOperand* Current() {
592    DCHECK(!current_iterator_.Done());
593    DCHECK(current_iterator_.Current() != NULL);
594    return current_iterator_.Current();
595  }
596
597  void Advance() {
598    current_iterator_.Advance();
599    SkipUninteresting();
600  }
601
602 private:
603  void SkipUninteresting() {
604    while (current_iterator_.env() != NULL && current_iterator_.Done()) {
605      current_iterator_ = ShallowIterator(current_iterator_.env()->outer());
606    }
607  }
608
609  ShallowIterator current_iterator_;
610};
611
612
613class LPlatformChunk;
614class LGap;
615class LLabel;
616
617// Superclass providing data and behavior common to all the
618// arch-specific LPlatformChunk classes.
619class LChunk : public ZoneObject {
620 public:
621  static LChunk* NewChunk(HGraph* graph);
622
623  void AddInstruction(LInstruction* instruction, HBasicBlock* block);
624  LConstantOperand* DefineConstantOperand(HConstant* constant);
625  HConstant* LookupConstant(LConstantOperand* operand) const;
626  Representation LookupLiteralRepresentation(LConstantOperand* operand) const;
627
628  int ParameterAt(int index);
629  int GetParameterStackSlot(int index) const;
630  int spill_slot_count() const { return spill_slot_count_; }
631  CompilationInfo* info() const { return info_; }
632  HGraph* graph() const { return graph_; }
633  Isolate* isolate() const { return graph_->isolate(); }
634  const ZoneList<LInstruction*>* instructions() const { return &instructions_; }
635  void AddGapMove(int index, LOperand* from, LOperand* to);
636  LGap* GetGapAt(int index) const;
637  bool IsGapAt(int index) const;
638  int NearestGapPos(int index) const;
639  void MarkEmptyBlocks();
640  const ZoneList<LPointerMap*>* pointer_maps() const { return &pointer_maps_; }
641  LLabel* GetLabel(int block_id) const;
642  int LookupDestination(int block_id) const;
643  Label* GetAssemblyLabel(int block_id) const;
644
645  const ZoneList<Handle<JSFunction> >* inlined_closures() const {
646    return &inlined_closures_;
647  }
648
649  void AddInlinedClosure(Handle<JSFunction> closure) {
650    inlined_closures_.Add(closure, zone());
651  }
652
653  void AddDeprecationDependency(Handle<Map> map) {
654    DCHECK(!map->is_deprecated());
655    if (!map->CanBeDeprecated()) return;
656    DCHECK(!info_->IsStub());
657    deprecation_dependencies_.insert(map);
658  }
659
660  void AddStabilityDependency(Handle<Map> map) {
661    DCHECK(map->is_stable());
662    if (!map->CanTransition()) return;
663    DCHECK(!info_->IsStub());
664    stability_dependencies_.insert(map);
665  }
666
667  Zone* zone() const { return info_->zone(); }
668
669  Handle<Code> Codegen();
670
671  void set_allocated_double_registers(BitVector* allocated_registers);
672  BitVector* allocated_double_registers() {
673    return allocated_double_registers_;
674  }
675
676 protected:
677  LChunk(CompilationInfo* info, HGraph* graph);
678
679  int spill_slot_count_;
680
681 private:
682  typedef std::less<Handle<Map> > MapLess;
683  typedef zone_allocator<Handle<Map> > MapAllocator;
684  typedef std::set<Handle<Map>, MapLess, MapAllocator> MapSet;
685
686  void CommitDependencies(Handle<Code> code) const;
687
688  CompilationInfo* info_;
689  HGraph* const graph_;
690  BitVector* allocated_double_registers_;
691  ZoneList<LInstruction*> instructions_;
692  ZoneList<LPointerMap*> pointer_maps_;
693  ZoneList<Handle<JSFunction> > inlined_closures_;
694  MapSet deprecation_dependencies_;
695  MapSet stability_dependencies_;
696};
697
698
699class LChunkBuilderBase BASE_EMBEDDED {
700 public:
701  explicit LChunkBuilderBase(CompilationInfo* info, HGraph* graph)
702      : argument_count_(0),
703        chunk_(NULL),
704        info_(info),
705        graph_(graph),
706        status_(UNUSED),
707        zone_(graph->zone()) {}
708
709  virtual ~LChunkBuilderBase() { }
710
711  void Abort(BailoutReason reason);
712  void Retry(BailoutReason reason);
713
714 protected:
715  enum Status { UNUSED, BUILDING, DONE, ABORTED };
716
717  LPlatformChunk* chunk() const { return chunk_; }
718  CompilationInfo* info() const { return info_; }
719  HGraph* graph() const { return graph_; }
720  int argument_count() const { return argument_count_; }
721  Isolate* isolate() const { return graph_->isolate(); }
722  Heap* heap() const { return isolate()->heap(); }
723
724  bool is_unused() const { return status_ == UNUSED; }
725  bool is_building() const { return status_ == BUILDING; }
726  bool is_done() const { return status_ == DONE; }
727  bool is_aborted() const { return status_ == ABORTED; }
728
729  // An input operand in register, stack slot or a constant operand.
730  // Will not be moved to a register even if one is freely available.
731  virtual MUST_USE_RESULT LOperand* UseAny(HValue* value) = 0;
732
733  LEnvironment* CreateEnvironment(HEnvironment* hydrogen_env,
734                                  int* argument_index_accumulator,
735                                  ZoneList<HValue*>* objects_to_materialize);
736  void AddObjectToMaterialize(HValue* value,
737                              ZoneList<HValue*>* objects_to_materialize,
738                              LEnvironment* result);
739
740  Zone* zone() const { return zone_; }
741
742  int argument_count_;
743  LPlatformChunk* chunk_;
744  CompilationInfo* info_;
745  HGraph* const graph_;
746  Status status_;
747
748 private:
749  Zone* zone_;
750};
751
752
753int StackSlotOffset(int index);
754
755enum NumberUntagDMode {
756  NUMBER_CANDIDATE_IS_SMI,
757  NUMBER_CANDIDATE_IS_ANY_TAGGED
758};
759
760
761class LPhase : public CompilationPhase {
762 public:
763  LPhase(const char* name, LChunk* chunk)
764      : CompilationPhase(name, chunk->info()),
765        chunk_(chunk) { }
766  ~LPhase();
767
768 private:
769  LChunk* chunk_;
770
771  DISALLOW_COPY_AND_ASSIGN(LPhase);
772};
773
774
775// A register-allocator view of a Lithium instruction. It contains the id of
776// the output operand and a list of input operand uses.
777
778enum RegisterKind {
779  UNALLOCATED_REGISTERS,
780  GENERAL_REGISTERS,
781  DOUBLE_REGISTERS
782};
783
784// Iterator for non-null temp operands.
785class TempIterator BASE_EMBEDDED {
786 public:
787  inline explicit TempIterator(LInstruction* instr);
788  inline bool Done();
789  inline LOperand* Current();
790  inline void Advance();
791
792 private:
793  inline void SkipUninteresting();
794  LInstruction* instr_;
795  int limit_;
796  int current_;
797};
798
799
800// Iterator for non-constant input operands.
801class InputIterator BASE_EMBEDDED {
802 public:
803  inline explicit InputIterator(LInstruction* instr);
804  inline bool Done();
805  inline LOperand* Current();
806  inline void Advance();
807
808 private:
809  inline void SkipUninteresting();
810  LInstruction* instr_;
811  int limit_;
812  int current_;
813};
814
815
816class UseIterator BASE_EMBEDDED {
817 public:
818  inline explicit UseIterator(LInstruction* instr);
819  inline bool Done();
820  inline LOperand* Current();
821  inline void Advance();
822
823 private:
824  InputIterator input_iterator_;
825  DeepIterator env_iterator_;
826};
827
828class LInstruction;
829class LCodeGen;
830} }  // namespace v8::internal
831
832#endif  // V8_LITHIUM_H_
833