1// Copyright 2013 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_ARM64_DELAYED_MASM_ARM64_H_
6#define V8_ARM64_DELAYED_MASM_ARM64_H_
7
8#include "src/lithium.h"
9
10namespace v8 {
11namespace internal {
12
13class LCodeGen;
14
15// This class delays the generation of some instructions. This way, we have a
16// chance to merge two instructions in one (with load/store pair).
17// Each instruction must either:
18//  - merge with the pending instruction and generate just one instruction.
19//  - emit the pending instruction and then generate the instruction (or set the
20//    pending instruction).
21class DelayedMasm BASE_EMBEDDED {
22 public:
23  DelayedMasm(LCodeGen* owner,
24              MacroAssembler* masm,
25              const Register& scratch_register)
26    : cgen_(owner), masm_(masm), scratch_register_(scratch_register),
27      scratch_register_used_(false), pending_(kNone), saved_value_(0) {
28#ifdef DEBUG
29    pending_register_ = no_reg;
30    pending_value_ = 0;
31    pending_pc_ = 0;
32    scratch_register_acquired_ = false;
33#endif
34  }
35  ~DelayedMasm() {
36    DCHECK(!scratch_register_acquired_);
37    DCHECK(!scratch_register_used_);
38    DCHECK(!pending());
39  }
40  inline void EndDelayedUse();
41
42  const Register& ScratchRegister() {
43    scratch_register_used_ = true;
44    return scratch_register_;
45  }
46  bool IsScratchRegister(const CPURegister& reg) {
47    return reg.Is(scratch_register_);
48  }
49  bool scratch_register_used() const { return scratch_register_used_; }
50  void reset_scratch_register_used() { scratch_register_used_ = false; }
51  // Acquire/Release scratch register for use outside this class.
52  void AcquireScratchRegister() {
53    EmitPending();
54    ResetSavedValue();
55#ifdef DEBUG
56    DCHECK(!scratch_register_acquired_);
57    scratch_register_acquired_ = true;
58#endif
59  }
60  void ReleaseScratchRegister() {
61#ifdef DEBUG
62    DCHECK(scratch_register_acquired_);
63    scratch_register_acquired_ = false;
64#endif
65  }
66  bool pending() { return pending_ != kNone; }
67
68  // Extra layer over the macro-assembler instructions (which emits the
69  // potential pending instruction).
70  inline void Mov(const Register& rd,
71                  const Operand& operand,
72                  DiscardMoveMode discard_mode = kDontDiscardForSameWReg);
73  inline void Fmov(FPRegister fd, FPRegister fn);
74  inline void Fmov(FPRegister fd, double imm);
75  inline void LoadObject(Register result, Handle<Object> object);
76  // Instructions which try to merge which the pending instructions.
77  void StackSlotMove(LOperand* src, LOperand* dst);
78  // StoreConstant can only be used if the scratch register is not acquired.
79  void StoreConstant(uint64_t value, const MemOperand& operand);
80  void Load(const CPURegister& rd, const MemOperand& operand);
81  void Store(const CPURegister& rd, const MemOperand& operand);
82  // Emit the potential pending instruction.
83  void EmitPending();
84  // Reset the pending state.
85  void ResetPending() {
86    pending_ = kNone;
87#ifdef DEBUG
88    pending_register_ = no_reg;
89    MemOperand tmp;
90    pending_address_src_ = tmp;
91    pending_address_dst_ = tmp;
92    pending_value_ = 0;
93    pending_pc_ = 0;
94#endif
95  }
96  void InitializeRootRegister() {
97    masm_->InitializeRootRegister();
98  }
99
100 private:
101  // Set the saved value and load the ScratchRegister with it.
102  void SetSavedValue(uint64_t saved_value) {
103    DCHECK(saved_value != 0);
104    if (saved_value_ != saved_value) {
105      masm_->Mov(ScratchRegister(), saved_value);
106      saved_value_ = saved_value;
107    }
108  }
109  // Reset the saved value (i.e. the value of ScratchRegister is no longer
110  // known).
111  void ResetSavedValue() {
112    saved_value_ = 0;
113  }
114
115  LCodeGen* cgen_;
116  MacroAssembler* masm_;
117
118  // Register used to store a constant.
119  Register scratch_register_;
120  bool scratch_register_used_;
121
122  // Sometimes we store or load two values in two contiguous stack slots.
123  // In this case, we try to use the ldp/stp instructions to reduce code size.
124  // To be able to do that, instead of generating directly the instructions,
125  // we register with the following fields that an instruction needs to be
126  // generated. Then with the next instruction, if the instruction is
127  // consistent with the pending one for stp/ldp we generate ldp/stp. Else,
128  // if they are not consistent, we generate the pending instruction and we
129  // register the new instruction (which becomes pending).
130
131  // Enumeration of instructions which can be pending.
132  enum Pending {
133    kNone,
134    kStoreConstant,
135    kLoad, kStore,
136    kStackSlotMove
137  };
138  // The pending instruction.
139  Pending pending_;
140  // For kLoad, kStore: register which must be loaded/stored.
141  CPURegister pending_register_;
142  // For kLoad, kStackSlotMove: address of the load.
143  MemOperand pending_address_src_;
144  // For kStoreConstant, kStore, kStackSlotMove: address of the store.
145  MemOperand pending_address_dst_;
146  // For kStoreConstant: value to be stored.
147  uint64_t pending_value_;
148  // Value held into the ScratchRegister if the saved_value_ is not 0.
149  // For 0, we use xzr.
150  uint64_t saved_value_;
151#ifdef DEBUG
152  // Address where the pending instruction must be generated. It's only used to
153  // check that nothing else has been generated since we set the pending
154  // instruction.
155  int pending_pc_;
156  // If true, the scratch register has been acquired outside this class. The
157  // scratch register can no longer be used for constants.
158  bool scratch_register_acquired_;
159#endif
160};
161
162} }  // namespace v8::internal
163
164#endif  // V8_ARM64_DELAYED_MASM_ARM64_H_
165