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 15 namespace v8 { 16 namespace internal { 17 namespace 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. 23 class 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 Simd128Register InputSimd128Register(size_t index) { 43 return ToSimd128Register(instr_->InputAt(index)); 44 } 45 46 double InputDouble(size_t index) { return ToDouble(instr_->InputAt(index)); } 47 48 float InputFloat32(size_t index) { return ToFloat32(instr_->InputAt(index)); } 49 50 int32_t InputInt32(size_t index) { 51 return ToConstant(instr_->InputAt(index)).ToInt32(); 52 } 53 54 uint32_t InputUint32(size_t index) { 55 return bit_cast<uint32_t>(InputInt32(index)); 56 } 57 58 int64_t InputInt64(size_t index) { 59 return ToConstant(instr_->InputAt(index)).ToInt64(); 60 } 61 62 int8_t InputInt8(size_t index) { 63 return static_cast<int8_t>(InputInt32(index)); 64 } 65 66 int16_t InputInt16(size_t index) { 67 return static_cast<int16_t>(InputInt32(index)); 68 } 69 70 uint8_t InputInt3(size_t index) { 71 return static_cast<uint8_t>(InputInt32(index) & 0x7); 72 } 73 74 uint8_t InputInt4(size_t index) { 75 return static_cast<uint8_t>(InputInt32(index) & 0xF); 76 } 77 78 uint8_t InputInt5(size_t index) { 79 return static_cast<uint8_t>(InputInt32(index) & 0x1F); 80 } 81 82 uint8_t InputInt6(size_t index) { 83 return static_cast<uint8_t>(InputInt32(index) & 0x3F); 84 } 85 86 ExternalReference InputExternalReference(size_t index) { 87 return ToExternalReference(instr_->InputAt(index)); 88 } 89 90 Handle<Code> InputCode(size_t index) { 91 return ToCode(instr_->InputAt(index)); 92 } 93 94 Label* InputLabel(size_t index) { return ToLabel(instr_->InputAt(index)); } 95 96 RpoNumber InputRpo(size_t index) { 97 return ToRpoNumber(instr_->InputAt(index)); 98 } 99 100 Register OutputRegister(size_t index = 0) { 101 return ToRegister(instr_->OutputAt(index)); 102 } 103 104 Register TempRegister(size_t index) { 105 return ToRegister(instr_->TempAt(index)); 106 } 107 108 FloatRegister OutputFloatRegister() { 109 return ToFloatRegister(instr_->Output()); 110 } 111 112 DoubleRegister OutputDoubleRegister() { 113 return ToDoubleRegister(instr_->Output()); 114 } 115 116 Simd128Register OutputSimd128Register() { 117 return ToSimd128Register(instr_->Output()); 118 } 119 120 // -- Conversions for operands ----------------------------------------------- 121 122 Label* ToLabel(InstructionOperand* op) { 123 return gen_->GetLabel(ToRpoNumber(op)); 124 } 125 126 RpoNumber ToRpoNumber(InstructionOperand* op) { 127 return ToConstant(op).ToRpoNumber(); 128 } 129 130 Register ToRegister(InstructionOperand* op) { 131 return LocationOperand::cast(op)->GetRegister(); 132 } 133 134 FloatRegister ToFloatRegister(InstructionOperand* op) { 135 return LocationOperand::cast(op)->GetFloatRegister(); 136 } 137 138 DoubleRegister ToDoubleRegister(InstructionOperand* op) { 139 return LocationOperand::cast(op)->GetDoubleRegister(); 140 } 141 142 Simd128Register ToSimd128Register(InstructionOperand* op) { 143 return LocationOperand::cast(op)->GetSimd128Register(); 144 } 145 146 Constant ToConstant(InstructionOperand* op) { 147 if (op->IsImmediate()) { 148 return gen_->code()->GetImmediate(ImmediateOperand::cast(op)); 149 } 150 return gen_->code()->GetConstant( 151 ConstantOperand::cast(op)->virtual_register()); 152 } 153 154 double ToDouble(InstructionOperand* op) { 155 return ToConstant(op).ToFloat64().value(); 156 } 157 158 float ToFloat32(InstructionOperand* op) { return ToConstant(op).ToFloat32(); } 159 160 ExternalReference ToExternalReference(InstructionOperand* op) { 161 return ToConstant(op).ToExternalReference(); 162 } 163 164 Handle<Code> ToCode(InstructionOperand* op) { 165 return ToConstant(op).ToCode(); 166 } 167 168 const Frame* frame() const { return gen_->frame(); } 169 FrameAccessState* frame_access_state() const { 170 return gen_->frame_access_state(); 171 } 172 Isolate* isolate() const { return gen_->isolate(); } 173 Linkage* linkage() const { return gen_->linkage(); } 174 175 protected: 176 CodeGenerator* gen_; 177 Instruction* instr_; 178 }; 179 180 // Eager deoptimization exit. 181 class DeoptimizationExit : public ZoneObject { 182 public: 183 explicit DeoptimizationExit(int deoptimization_id, SourcePosition pos) 184 : deoptimization_id_(deoptimization_id), pos_(pos) {} 185 186 int deoptimization_id() const { return deoptimization_id_; } 187 Label* label() { return &label_; } 188 SourcePosition pos() const { return pos_; } 189 190 private: 191 int const deoptimization_id_; 192 Label label_; 193 SourcePosition const pos_; 194 }; 195 196 // Generator for out-of-line code that is emitted after the main code is done. 197 class OutOfLineCode : public ZoneObject { 198 public: 199 explicit OutOfLineCode(CodeGenerator* gen); 200 virtual ~OutOfLineCode(); 201 202 virtual void Generate() = 0; 203 204 Label* entry() { return &entry_; } 205 Label* exit() { return &exit_; } 206 const Frame* frame() const { return frame_; } 207 TurboAssembler* tasm() { return tasm_; } 208 OutOfLineCode* next() const { return next_; } 209 210 private: 211 Label entry_; 212 Label exit_; 213 const Frame* const frame_; 214 TurboAssembler* const tasm_; 215 OutOfLineCode* const next_; 216 }; 217 218 inline bool HasCallDescriptorFlag(Instruction* instr, 219 CallDescriptor::Flag flag) { 220 return MiscField::decode(instr->opcode()) & flag; 221 } 222 223 } // namespace compiler 224 } // namespace internal 225 } // namespace v8 226 227 #endif // V8_COMPILER_CODE_GENERATOR_IMPL_H_ 228