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_COMPILER_CODE_GENERATOR_IMPL_H_
6#define V8_COMPILER_CODE_GENERATOR_IMPL_H_
7
8#include "src/code-stubs.h"
9#include "src/compiler/code-generator.h"
10#include "src/compiler/instruction.h"
11#include "src/compiler/linkage.h"
12#include "src/compiler/opcodes.h"
13#include "src/macro-assembler.h"
14
15namespace v8 {
16namespace internal {
17namespace compiler {
18
19// Converts InstructionOperands from a given instruction to
20// architecture-specific
21// registers and operands after they have been assigned by the register
22// allocator.
23class InstructionOperandConverter {
24 public:
25  InstructionOperandConverter(CodeGenerator* gen, Instruction* instr)
26      : gen_(gen), instr_(instr) {}
27
28  // -- Instruction operand accesses with conversions --------------------------
29
30  Register InputRegister(size_t index) {
31    return ToRegister(instr_->InputAt(index));
32  }
33
34  FloatRegister InputFloatRegister(size_t index) {
35    return ToFloatRegister(instr_->InputAt(index));
36  }
37
38  DoubleRegister InputDoubleRegister(size_t index) {
39    return ToDoubleRegister(instr_->InputAt(index));
40  }
41
42  double InputDouble(size_t index) { return ToDouble(instr_->InputAt(index)); }
43
44  float InputFloat32(size_t index) { return ToFloat32(instr_->InputAt(index)); }
45
46  int32_t InputInt32(size_t index) {
47    return ToConstant(instr_->InputAt(index)).ToInt32();
48  }
49
50  uint32_t InputUint32(size_t index) {
51    return bit_cast<uint32_t>(InputInt32(index));
52  }
53
54  int64_t InputInt64(size_t index) {
55    return ToConstant(instr_->InputAt(index)).ToInt64();
56  }
57
58  int8_t InputInt8(size_t index) {
59    return static_cast<int8_t>(InputInt32(index));
60  }
61
62  int16_t InputInt16(size_t index) {
63    return static_cast<int16_t>(InputInt32(index));
64  }
65
66  uint8_t InputInt5(size_t index) {
67    return static_cast<uint8_t>(InputInt32(index) & 0x1F);
68  }
69
70  uint8_t InputInt6(size_t index) {
71    return static_cast<uint8_t>(InputInt32(index) & 0x3F);
72  }
73
74  ExternalReference InputExternalReference(size_t index) {
75    return ToExternalReference(instr_->InputAt(index));
76  }
77
78  Handle<HeapObject> InputHeapObject(size_t index) {
79    return ToHeapObject(instr_->InputAt(index));
80  }
81
82  Label* InputLabel(size_t index) { return ToLabel(instr_->InputAt(index)); }
83
84  RpoNumber InputRpo(size_t index) {
85    return ToRpoNumber(instr_->InputAt(index));
86  }
87
88  Register OutputRegister(size_t index = 0) {
89    return ToRegister(instr_->OutputAt(index));
90  }
91
92  Register TempRegister(size_t index) {
93    return ToRegister(instr_->TempAt(index));
94  }
95
96  FloatRegister OutputFloatRegister() {
97    return ToFloatRegister(instr_->Output());
98  }
99
100  DoubleRegister OutputDoubleRegister() {
101    return ToDoubleRegister(instr_->Output());
102  }
103
104  // -- Conversions for operands -----------------------------------------------
105
106  Label* ToLabel(InstructionOperand* op) {
107    return gen_->GetLabel(ToRpoNumber(op));
108  }
109
110  RpoNumber ToRpoNumber(InstructionOperand* op) {
111    return ToConstant(op).ToRpoNumber();
112  }
113
114  Register ToRegister(InstructionOperand* op) {
115    return LocationOperand::cast(op)->GetRegister();
116  }
117
118  DoubleRegister ToDoubleRegister(InstructionOperand* op) {
119    return LocationOperand::cast(op)->GetDoubleRegister();
120  }
121
122  FloatRegister ToFloatRegister(InstructionOperand* op) {
123    return LocationOperand::cast(op)->GetFloatRegister();
124  }
125
126  Constant ToConstant(InstructionOperand* op) {
127    if (op->IsImmediate()) {
128      return gen_->code()->GetImmediate(ImmediateOperand::cast(op));
129    }
130    return gen_->code()->GetConstant(
131        ConstantOperand::cast(op)->virtual_register());
132  }
133
134  double ToDouble(InstructionOperand* op) { return ToConstant(op).ToFloat64(); }
135
136  float ToFloat32(InstructionOperand* op) { return ToConstant(op).ToFloat32(); }
137
138  ExternalReference ToExternalReference(InstructionOperand* op) {
139    return ToConstant(op).ToExternalReference();
140  }
141
142  Handle<HeapObject> ToHeapObject(InstructionOperand* op) {
143    return ToConstant(op).ToHeapObject();
144  }
145
146  const Frame* frame() const { return gen_->frame(); }
147  FrameAccessState* frame_access_state() const {
148    return gen_->frame_access_state();
149  }
150  Isolate* isolate() const { return gen_->isolate(); }
151  Linkage* linkage() const { return gen_->linkage(); }
152
153 protected:
154  CodeGenerator* gen_;
155  Instruction* instr_;
156};
157
158// Eager deoptimization exit.
159class DeoptimizationExit : public ZoneObject {
160 public:
161  explicit DeoptimizationExit(int deoptimization_id)
162      : deoptimization_id_(deoptimization_id) {}
163
164  int deoptimization_id() const { return deoptimization_id_; }
165  Label* label() { return &label_; }
166
167 private:
168  int const deoptimization_id_;
169  Label label_;
170};
171
172// Generator for out-of-line code that is emitted after the main code is done.
173class OutOfLineCode : public ZoneObject {
174 public:
175  explicit OutOfLineCode(CodeGenerator* gen);
176  virtual ~OutOfLineCode();
177
178  virtual void Generate() = 0;
179
180  Label* entry() { return &entry_; }
181  Label* exit() { return &exit_; }
182  const Frame* frame() const { return frame_; }
183  Isolate* isolate() const { return masm()->isolate(); }
184  MacroAssembler* masm() const { return masm_; }
185  OutOfLineCode* next() const { return next_; }
186
187 private:
188  Label entry_;
189  Label exit_;
190  const Frame* const frame_;
191  MacroAssembler* const masm_;
192  OutOfLineCode* const next_;
193};
194
195
196// TODO(dcarney): generify this on bleeding_edge and replace this call
197// when merged.
198static inline void FinishCode(MacroAssembler* masm) {
199#if V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_ARM
200  masm->CheckConstPool(true, false);
201#elif V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64
202  masm->ud2();
203#endif
204}
205
206}  // namespace compiler
207}  // namespace internal
208}  // namespace v8
209
210#endif  // V8_COMPILER_CODE_GENERATOR_IMPL_H
211