Home | History | Annotate | Download | only in compiler 
      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 InputInt5(size_t index) {
     71     return static_cast<uint8_t>(InputInt32(index) & 0x1F);
     72   }
     73 
     74   uint8_t InputInt6(size_t index) {
     75     return static_cast<uint8_t>(InputInt32(index) & 0x3F);
     76   }
     77 
     78   ExternalReference InputExternalReference(size_t index) {
     79     return ToExternalReference(instr_->InputAt(index));
     80   }
     81 
     82   Handle<HeapObject> InputHeapObject(size_t index) {
     83     return ToHeapObject(instr_->InputAt(index));
     84   }
     85 
     86   Label* InputLabel(size_t index) { return ToLabel(instr_->InputAt(index)); }
     87 
     88   RpoNumber InputRpo(size_t index) {
     89     return ToRpoNumber(instr_->InputAt(index));
     90   }
     91 
     92   Register OutputRegister(size_t index = 0) {
     93     return ToRegister(instr_->OutputAt(index));
     94   }
     95 
     96   Register TempRegister(size_t index) {
     97     return ToRegister(instr_->TempAt(index));
     98   }
     99 
    100   FloatRegister OutputFloatRegister() {
    101     return ToFloatRegister(instr_->Output());
    102   }
    103 
    104   DoubleRegister OutputDoubleRegister() {
    105     return ToDoubleRegister(instr_->Output());
    106   }
    107 
    108   Simd128Register OutputSimd128Register() {
    109     return ToSimd128Register(instr_->Output());
    110   }
    111 
    112   // -- Conversions for operands -----------------------------------------------
    113 
    114   Label* ToLabel(InstructionOperand* op) {
    115     return gen_->GetLabel(ToRpoNumber(op));
    116   }
    117 
    118   RpoNumber ToRpoNumber(InstructionOperand* op) {
    119     return ToConstant(op).ToRpoNumber();
    120   }
    121 
    122   Register ToRegister(InstructionOperand* op) {
    123     return LocationOperand::cast(op)->GetRegister();
    124   }
    125 
    126   FloatRegister ToFloatRegister(InstructionOperand* op) {
    127     return LocationOperand::cast(op)->GetFloatRegister();
    128   }
    129 
    130   DoubleRegister ToDoubleRegister(InstructionOperand* op) {
    131     return LocationOperand::cast(op)->GetDoubleRegister();
    132   }
    133 
    134   Simd128Register ToSimd128Register(InstructionOperand* op) {
    135     return LocationOperand::cast(op)->GetSimd128Register();
    136   }
    137 
    138   Constant ToConstant(InstructionOperand* op) {
    139     if (op->IsImmediate()) {
    140       return gen_->code()->GetImmediate(ImmediateOperand::cast(op));
    141     }
    142     return gen_->code()->GetConstant(
    143         ConstantOperand::cast(op)->virtual_register());
    144   }
    145 
    146   double ToDouble(InstructionOperand* op) { return ToConstant(op).ToFloat64(); }
    147 
    148   float ToFloat32(InstructionOperand* op) { return ToConstant(op).ToFloat32(); }
    149 
    150   ExternalReference ToExternalReference(InstructionOperand* op) {
    151     return ToConstant(op).ToExternalReference();
    152   }
    153 
    154   Handle<HeapObject> ToHeapObject(InstructionOperand* op) {
    155     return ToConstant(op).ToHeapObject();
    156   }
    157 
    158   const Frame* frame() const { return gen_->frame(); }
    159   FrameAccessState* frame_access_state() const {
    160     return gen_->frame_access_state();
    161   }
    162   Isolate* isolate() const { return gen_->isolate(); }
    163   Linkage* linkage() const { return gen_->linkage(); }
    164 
    165  protected:
    166   CodeGenerator* gen_;
    167   Instruction* instr_;
    168 };
    169 
    170 // Eager deoptimization exit.
    171 class DeoptimizationExit : public ZoneObject {
    172  public:
    173   explicit DeoptimizationExit(int deoptimization_id, SourcePosition pos)
    174       : deoptimization_id_(deoptimization_id), pos_(pos) {}
    175 
    176   int deoptimization_id() const { return deoptimization_id_; }
    177   Label* label() { return &label_; }
    178   SourcePosition pos() const { return pos_; }
    179 
    180  private:
    181   int const deoptimization_id_;
    182   Label label_;
    183   SourcePosition const pos_;
    184 };
    185 
    186 // Generator for out-of-line code that is emitted after the main code is done.
    187 class OutOfLineCode : public ZoneObject {
    188  public:
    189   explicit OutOfLineCode(CodeGenerator* gen);
    190   virtual ~OutOfLineCode();
    191 
    192   virtual void Generate() = 0;
    193 
    194   Label* entry() { return &entry_; }
    195   Label* exit() { return &exit_; }
    196   const Frame* frame() const { return frame_; }
    197   Isolate* isolate() const { return masm()->isolate(); }
    198   MacroAssembler* masm() const { return masm_; }
    199   OutOfLineCode* next() const { return next_; }
    200 
    201  private:
    202   Label entry_;
    203   Label exit_;
    204   const Frame* const frame_;
    205   MacroAssembler* const masm_;
    206   OutOfLineCode* const next_;
    207 };
    208 
    209 
    210 // TODO(dcarney): generify this on bleeding_edge and replace this call
    211 // when merged.
    212 static inline void FinishCode(MacroAssembler* masm) {
    213 #if V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_ARM
    214   masm->CheckConstPool(true, false);
    215 #endif
    216 }
    217 
    218 }  // namespace compiler
    219 }  // namespace internal
    220 }  // namespace v8
    221 
    222 #endif  // V8_COMPILER_CODE_GENERATOR_IMPL_H
    223