src/v8/src/compiler/code-generator-impl.h

   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/compiler/code-generator.h"
   9 #include "src/compiler/common-operator.h"
  10 #include "src/compiler/generic-graph.h"
  11 #include "src/compiler/instruction.h"
  12 #include "src/compiler/linkage.h"
  13 #include "src/compiler/machine-operator.h"
  14 #include "src/compiler/node.h"
  15 #include "src/compiler/opcodes.h"
  16 #include "src/compiler/operator.h"
  17
  18 namespace v8 {
  19 namespace internal {
  20 namespace compiler {
  21
  22 // Converts InstructionOperands from a given instruction to
  23 // architecture-specific
  24 // registers and operands after they have been assigned by the register
  25 // allocator.
  26 class InstructionOperandConverter {
  27  public:
  28   InstructionOperandConverter(CodeGenerator* gen, Instruction* instr)
  29       : gen_(gen), instr_(instr) {}
  30
  31   Register InputRegister(int index) {
  32     return ToRegister(instr_->InputAt(index));
  33   }
  34
  35   DoubleRegister InputDoubleRegister(int index) {
  36     return ToDoubleRegister(instr_->InputAt(index));
  37   }
  38
  39   double InputDouble(int index) { return ToDouble(instr_->InputAt(index)); }
  40
  41   int32_t InputInt32(int index) {
  42     return ToConstant(instr_->InputAt(index)).ToInt32();
  43   }
  44
  45   int8_t InputInt8(int index) { return static_cast<int8_t>(InputInt32(index)); }
  46
  47   int16_t InputInt16(int index) {
  48     return static_cast<int16_t>(InputInt32(index));
  49   }
  50
  51   uint8_t InputInt5(int index) {
  52     return static_cast<uint8_t>(InputInt32(index) & 0x1F);
  53   }
  54
  55   uint8_t InputInt6(int index) {
  56     return static_cast<uint8_t>(InputInt32(index) & 0x3F);
  57   }
  58
  59   Handle<HeapObject> InputHeapObject(int index) {
  60     return ToHeapObject(instr_->InputAt(index));
  61   }
  62
  63   Label* InputLabel(int index) {
  64     return gen_->code()->GetLabel(InputBlock(index));
  65   }
  66
  67   BasicBlock* InputBlock(int index) {
  68     NodeId block_id = static_cast<NodeId>(InputInt32(index));
  69     // operand should be a block id.
  70     DCHECK(block_id >= 0);
  71     DCHECK(block_id < gen_->schedule()->BasicBlockCount());
  72     return gen_->schedule()->GetBlockById(block_id);
  73   }
  74
  75   Register OutputRegister(int index = 0) {
  76     return ToRegister(instr_->OutputAt(index));
  77   }
  78
  79   DoubleRegister OutputDoubleRegister() {
  80     return ToDoubleRegister(instr_->Output());
  81   }
  82
  83   Register TempRegister(int index) { return ToRegister(instr_->TempAt(index)); }
  84
  85   Register ToRegister(InstructionOperand* op) {
  86     DCHECK(op->IsRegister());
  87     return Register::FromAllocationIndex(op->index());
  88   }
  89
  90   DoubleRegister ToDoubleRegister(InstructionOperand* op) {
  91     DCHECK(op->IsDoubleRegister());
  92     return DoubleRegister::FromAllocationIndex(op->index());
  93   }
  94
  95   Constant ToConstant(InstructionOperand* operand) {
  96     if (operand->IsImmediate()) {
  97       return gen_->code()->GetImmediate(operand->index());
  98     }
  99     return gen_->code()->GetConstant(operand->index());
 100   }
 101
 102   double ToDouble(InstructionOperand* operand) {
 103     return ToConstant(operand).ToFloat64();
 104   }
 105
 106   Handle<HeapObject> ToHeapObject(InstructionOperand* operand) {
 107     return ToConstant(operand).ToHeapObject();
 108   }
 109
 110   Frame* frame() const { return gen_->frame(); }
 111   Isolate* isolate() const { return gen_->isolate(); }
 112   Linkage* linkage() const { return gen_->linkage(); }
 113
 114  protected:
 115   CodeGenerator* gen_;
 116   Instruction* instr_;
 117 };
 118
 119
 120 // TODO(dcarney): generify this on bleeding_edge and replace this call
 121 // when merged.
 122 static inline void FinishCode(MacroAssembler* masm) {
 123 #if V8_TARGET_ARCH_ARM64 || V8_TARGET_ARCH_ARM
 124   masm->CheckConstPool(true, false);
 125 #endif
 126 }
 127
 128 }  // namespace compiler
 129 }  // namespace internal
 130 }  // namespace v8
 131
 132 #endif  // V8_COMPILER_CODE_GENERATOR_IMPL_H