src/v8/src/compiler/instruction-selector.h

   1 // Copyright 2014 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_INSTRUCTION_SELECTOR_H_
   6 #define V8_COMPILER_INSTRUCTION_SELECTOR_H_
   7
   8 #include <deque>
   9
  10 #include "src/compiler/common-operator.h"
  11 #include "src/compiler/instruction.h"
  12 #include "src/compiler/machine-operator.h"
  13 #include "src/zone-containers.h"
  14
  15 namespace v8 {
  16 namespace internal {
  17 namespace compiler {
  18
  19 // Forward declarations.
  20 struct CallBuffer;  // TODO(bmeurer): Remove this.
  21 class FlagsContinuation;
  22
  23 class InstructionSelector FINAL {
  24  public:
  25   // Forward declarations.
  26   class Features;
  27
  28   InstructionSelector(InstructionSequence* sequence,
  29                       SourcePositionTable* source_positions,
  30                       Features features = SupportedFeatures());
  31
  32   // Visit code for the entire graph with the included schedule.
  33   void SelectInstructions();
  34
  35   // ===========================================================================
  36   // ============= Architecture-independent code emission methods. =============
  37   // ===========================================================================
  38
  39   Instruction* Emit(InstructionCode opcode, InstructionOperand* output,
  40                     size_t temp_count = 0, InstructionOperand* *temps = NULL);
  41   Instruction* Emit(InstructionCode opcode, InstructionOperand* output,
  42                     InstructionOperand* a, size_t temp_count = 0,
  43                     InstructionOperand* *temps = NULL);
  44   Instruction* Emit(InstructionCode opcode, InstructionOperand* output,
  45                     InstructionOperand* a, InstructionOperand* b,
  46                     size_t temp_count = 0, InstructionOperand* *temps = NULL);
  47   Instruction* Emit(InstructionCode opcode, InstructionOperand* output,
  48                     InstructionOperand* a, InstructionOperand* b,
  49                     InstructionOperand* c, size_t temp_count = 0,
  50                     InstructionOperand* *temps = NULL);
  51   Instruction* Emit(InstructionCode opcode, InstructionOperand* output,
  52                     InstructionOperand* a, InstructionOperand* b,
  53                     InstructionOperand* c, InstructionOperand* d,
  54                     size_t temp_count = 0, InstructionOperand* *temps = NULL);
  55   Instruction* Emit(InstructionCode opcode, size_t output_count,
  56                     InstructionOperand** outputs, size_t input_count,
  57                     InstructionOperand** inputs, size_t temp_count = 0,
  58                     InstructionOperand* *temps = NULL);
  59   Instruction* Emit(Instruction* instr);
  60
  61   // ===========================================================================
  62   // ============== Architecture-independent CPU feature methods. ==============
  63   // ===========================================================================
  64
  65   class Features FINAL {
  66    public:
  67     Features() : bits_(0) {}
  68     explicit Features(unsigned bits) : bits_(bits) {}
  69     explicit Features(CpuFeature f) : bits_(1u << f) {}
  70     Features(CpuFeature f1, CpuFeature f2) : bits_((1u << f1) | (1u << f2)) {}
  71
  72     bool Contains(CpuFeature f) const { return (bits_ & (1u << f)); }
  73
  74    private:
  75     unsigned bits_;
  76   };
  77
  78   bool IsSupported(CpuFeature feature) const {
  79     return features_.Contains(feature);
  80   }
  81
  82   // Returns the features supported on the target platform.
  83   static Features SupportedFeatures() {
  84     return Features(CpuFeatures::SupportedFeatures());
  85   }
  86
  87  private:
  88   friend class OperandGenerator;
  89
  90   // ===========================================================================
  91   // ============ Architecture-independent graph covering methods. =============
  92   // ===========================================================================
  93
  94   // Checks if {block} will appear directly after {current_block_} when
  95   // assembling code, in which case, a fall-through can be used.
  96   bool IsNextInAssemblyOrder(const BasicBlock* block) const;
  97
  98   // Used in pattern matching during code generation.
  99   // Check if {node} can be covered while generating code for the current
 100   // instruction. A node can be covered if the {user} of the node has the only
 101   // edge and the two are in the same basic block.
 102   bool CanCover(Node* user, Node* node) const;
 103
 104   // Checks if {node} was already defined, and therefore code was already
 105   // generated for it.
 106   bool IsDefined(Node* node) const;
 107
 108   // Inform the instruction selection that {node} was just defined.
 109   void MarkAsDefined(Node* node);
 110
 111   // Checks if {node} has any uses, and therefore code has to be generated for
 112   // it.
 113   bool IsUsed(Node* node) const;
 114
 115   // Inform the instruction selection that {node} has at least one use and we
 116   // will need to generate code for it.
 117   void MarkAsUsed(Node* node);
 118
 119   // Checks if {node} is marked as double.
 120   bool IsDouble(const Node* node) const;
 121
 122   // Inform the register allocator of a double result.
 123   void MarkAsDouble(Node* node);
 124
 125   // Checks if {node} is marked as reference.
 126   bool IsReference(const Node* node) const;
 127
 128   // Inform the register allocator of a reference result.
 129   void MarkAsReference(Node* node);
 130
 131   // Inform the register allocation of the representation of the value produced
 132   // by {node}.
 133   void MarkAsRepresentation(MachineType rep, Node* node);
 134
 135   // Initialize the call buffer with the InstructionOperands, nodes, etc,
 136   // corresponding
 137   // to the inputs and outputs of the call.
 138   // {call_code_immediate} to generate immediate operands to calls of code.
 139   // {call_address_immediate} to generate immediate operands to address calls.
 140   void InitializeCallBuffer(Node* call, CallBuffer* buffer,
 141                             bool call_code_immediate,
 142                             bool call_address_immediate);
 143
 144   FrameStateDescriptor* GetFrameStateDescriptor(Node* node);
 145   void AddFrameStateInputs(Node* state, InstructionOperandVector* inputs,
 146                            FrameStateDescriptor* descriptor);
 147
 148   // ===========================================================================
 149   // ============= Architecture-specific graph covering methods. ===============
 150   // ===========================================================================
 151
 152   // Visit nodes in the given block and generate code.
 153   void VisitBlock(BasicBlock* block);
 154
 155   // Visit the node for the control flow at the end of the block, generating
 156   // code if necessary.
 157   void VisitControl(BasicBlock* block);
 158
 159   // Visit the node and generate code, if any.
 160   void VisitNode(Node* node);
 161
 162 #define DECLARE_GENERATOR(x) void Visit##x(Node* node);
 163   MACHINE_OP_LIST(DECLARE_GENERATOR)
 164 #undef DECLARE_GENERATOR
 165
 166   void VisitInt32AddWithOverflow(Node* node, FlagsContinuation* cont);
 167   void VisitInt32SubWithOverflow(Node* node, FlagsContinuation* cont);
 168
 169   void VisitWord32Test(Node* node, FlagsContinuation* cont);
 170   void VisitWord64Test(Node* node, FlagsContinuation* cont);
 171   void VisitWord32Compare(Node* node, FlagsContinuation* cont);
 172   void VisitWord64Compare(Node* node, FlagsContinuation* cont);
 173   void VisitFloat64Compare(Node* node, FlagsContinuation* cont);
 174
 175   void VisitFinish(Node* node);
 176   void VisitParameter(Node* node);
 177   void VisitPhi(Node* node);
 178   void VisitProjection(Node* node);
 179   void VisitConstant(Node* node);
 180   void VisitCall(Node* call, BasicBlock* continuation,
 181                  BasicBlock* deoptimization);
 182   void VisitGoto(BasicBlock* target);
 183   void VisitBranch(Node* input, BasicBlock* tbranch, BasicBlock* fbranch);
 184   void VisitReturn(Node* value);
 185   void VisitThrow(Node* value);
 186   void VisitDeoptimize(Node* deopt);
 187
 188   // ===========================================================================
 189
 190   Graph* graph() const { return sequence()->graph(); }
 191   Linkage* linkage() const { return sequence()->linkage(); }
 192   Schedule* schedule() const { return sequence()->schedule(); }
 193   InstructionSequence* sequence() const { return sequence_; }
 194   Zone* instruction_zone() const { return sequence()->zone(); }
 195   Zone* zone() { return &zone_; }
 196
 197   // ===========================================================================
 198
 199   Zone zone_;
 200   InstructionSequence* sequence_;
 201   SourcePositionTable* source_positions_;
 202   Features features_;
 203   BasicBlock* current_block_;
 204   ZoneDeque<Instruction*> instructions_;
 205   BoolVector defined_;
 206   BoolVector used_;
 207 };
 208
 209 }  // namespace compiler
 210 }  // namespace internal
 211 }  // namespace v8
 212
 213 #endif  // V8_COMPILER_INSTRUCTION_SELECTOR_H_