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   DoubleRegister InputDoubleRegister(size_t index) {
     35     return ToDoubleRegister(instr_->InputAt(index));
     36   }
     37 
     38   double InputDouble(size_t index) { return ToDouble(instr_->InputAt(index)); }
     39 
     40   float InputFloat32(size_t index) { return ToFloat32(instr_->InputAt(index)); }
     41 
     42   int32_t InputInt32(size_t index) {
     43     return ToConstant(instr_->InputAt(index)).ToInt32();
     44   }
     45 
     46   int64_t InputInt64(size_t index) {
     47     return ToConstant(instr_->InputAt(index)).ToInt64();
     48   }
     49 
     50   int8_t InputInt8(size_t index) {
     51     return static_cast<int8_t>(InputInt32(index));
     52   }
     53 
     54   int16_t InputInt16(size_t index) {
     55     return static_cast<int16_t>(InputInt32(index));
     56   }
     57 
     58   uint8_t InputInt5(size_t index) {
     59     return static_cast<uint8_t>(InputInt32(index) & 0x1F);
     60   }
     61 
     62   uint8_t InputInt6(size_t index) {
     63     return static_cast<uint8_t>(InputInt32(index) & 0x3F);
     64   }
     65 
     66   ExternalReference InputExternalReference(size_t index) {
     67     return ToExternalReference(instr_->InputAt(index));
     68   }
     69 
     70   Handle<HeapObject> InputHeapObject(size_t index) {
     71     return ToHeapObject(instr_->InputAt(index));
     72   }
     73 
     74   Label* InputLabel(size_t index) { return ToLabel(instr_->InputAt(index)); }
     75 
     76   RpoNumber InputRpo(size_t index) {
     77     return ToRpoNumber(instr_->InputAt(index));
     78   }
     79 
     80   Register OutputRegister(size_t index = 0) {
     81     return ToRegister(instr_->OutputAt(index));
     82   }
     83 
     84   Register TempRegister(size_t index) {
     85     return ToRegister(instr_->TempAt(index));
     86   }
     87 
     88   DoubleRegister OutputDoubleRegister() {
     89     return ToDoubleRegister(instr_->Output());
     90   }
     91 
     92   // -- Conversions for operands -----------------------------------------------
     93 
     94   Label* ToLabel(InstructionOperand* op) {
     95     return gen_->GetLabel(ToRpoNumber(op));
     96   }
     97 
     98   RpoNumber ToRpoNumber(InstructionOperand* op) {
     99     return ToConstant(op).ToRpoNumber();
    100   }
    101 
    102   Register ToRegister(InstructionOperand* op) {
    103     return LocationOperand::cast(op)->GetRegister();
    104   }
    105 
    106   DoubleRegister ToDoubleRegister(InstructionOperand* op) {
    107     return LocationOperand::cast(op)->GetDoubleRegister();
    108   }
    109 
    110   Constant ToConstant(InstructionOperand* op) {
    111     if (op->IsImmediate()) {
    112       return gen_->code()->GetImmediate(ImmediateOperand::cast(op));
    113     }
    114     return gen_->code()->GetConstant(
    115         ConstantOperand::cast(op)->virtual_register());
    116   }
    117 
    118   double ToDouble(InstructionOperand* op) { return ToConstant(op).ToFloat64(); }
    119 
    120   float ToFloat32(InstructionOperand* op) { return ToConstant(op).ToFloat32(); }
    121 
    122   ExternalReference ToExternalReference(InstructionOperand* op) {
    123     return ToConstant(op).ToExternalReference();
    124   }
    125 
    126   Handle<HeapObject> ToHeapObject(InstructionOperand* op) {
    127     return ToConstant(op).ToHeapObject();
    128   }
    129 
    130   Frame* frame() const { return gen_->frame(); }
    131   FrameAccessState* frame_access_state() const {
    132     return gen_->frame_access_state();
    133   }
    134   Isolate* isolate() const { return gen_->isolate(); }
    135   Linkage* linkage() const { return gen_->linkage(); }
    136 
    137  protected:
    138   CodeGenerator* gen_;
    139   Instruction* instr_;
    140 };
    141 
    142 
    143 // Generator for out-of-line code that is emitted after the main code is done.
    144 class OutOfLineCode : public ZoneObject {
    145  public:
    146   explicit OutOfLineCode(CodeGenerator* gen);
    147   virtual ~OutOfLineCode();
    148 
    149   virtual void Generate() = 0;
    150 
    151   Label* entry() { return &entry_; }
    152   Label* exit() { return &exit_; }
    153   Frame* frame() const { return frame_; }
    154   Isolate* isolate() const { return masm()->isolate(); }
    155   MacroAssembler* masm() const { return masm_; }
    156   OutOfLineCode* next() const { return next_; }
    157 
    158  private:
    159   Label entry_;
    160   Label exit_;
    161   Frame* const frame_;
    162   MacroAssembler* const masm_;
    163   OutOfLineCode* const next_;
    164 };
    165 
    166 
    167 // TODO(dcarney): generify this on bleeding_edge and replace this call
    168 // when merged.
    169 static inline void FinishCode(MacroAssembler* masm) {
    170 #if V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_ARM
    171   masm->CheckConstPool(true, false);
    172 #elif V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64
    173   masm->ud2();
    174 #endif
    175 }
    176 
    177 }  // namespace compiler
    178 }  // namespace internal
    179 }  // namespace v8
    180 
    181 #endif  // V8_COMPILER_CODE_GENERATOR_IMPL_H
    182