LCOV - code coverage report
Current view: top level - src/compiler - code-generator.h (source / functions) Hit Total Coverage
Test: app.info Lines: 7 7 100.0 %
Date: 2017-04-26 Functions: 1 2 50.0 %

          Line data    Source code
       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_CODE_GENERATOR_H_
       6             : #define V8_COMPILER_CODE_GENERATOR_H_
       7             : 
       8             : #include "src/compiler/gap-resolver.h"
       9             : #include "src/compiler/instruction.h"
      10             : #include "src/compiler/unwinding-info-writer.h"
      11             : #include "src/deoptimizer.h"
      12             : #include "src/macro-assembler.h"
      13             : #include "src/safepoint-table.h"
      14             : #include "src/source-position-table.h"
      15             : #include "src/trap-handler/trap-handler.h"
      16             : 
      17             : namespace v8 {
      18             : namespace internal {
      19             : 
      20             : class CompilationInfo;
      21             : 
      22             : namespace compiler {
      23             : 
      24             : // Forward declarations.
      25             : class DeoptimizationExit;
      26             : class FrameAccessState;
      27             : class Linkage;
      28             : class OutOfLineCode;
      29             : 
      30             : struct BranchInfo {
      31             :   FlagsCondition condition;
      32             :   Label* true_label;
      33             :   Label* false_label;
      34             :   bool fallthru;
      35             : };
      36             : 
      37             : 
      38             : class InstructionOperandIterator {
      39             :  public:
      40             :   InstructionOperandIterator(Instruction* instr, size_t pos)
      41     4411708 :       : instr_(instr), pos_(pos) {}
      42             : 
      43             :   Instruction* instruction() const { return instr_; }
      44    31696858 :   InstructionOperand* Advance() { return instr_->InputAt(pos_++); }
      45             : 
      46             :  private:
      47             :   Instruction* instr_;
      48             :   size_t pos_;
      49             : };
      50             : 
      51             : 
      52             : // Generates native code for a sequence of instructions.
      53     1824784 : class CodeGenerator final : public GapResolver::Assembler {
      54             :  public:
      55             :   explicit CodeGenerator(Frame* frame, Linkage* linkage,
      56             :                          InstructionSequence* code, CompilationInfo* info);
      57             : 
      58             :   // Generate native code.
      59             :   Handle<Code> GenerateCode();
      60             : 
      61             :   InstructionSequence* code() const { return code_; }
      62             :   FrameAccessState* frame_access_state() const { return frame_access_state_; }
      63     6651553 :   const Frame* frame() const { return frame_access_state_->frame(); }
      64             :   Isolate* isolate() const;
      65             :   Linkage* linkage() const { return linkage_; }
      66             : 
      67    20409461 :   Label* GetLabel(RpoNumber rpo) { return &labels_[rpo.ToSize()]; }
      68             : 
      69             :   void AssembleSourcePosition(Instruction* instr);
      70             : 
      71             :   void AssembleSourcePosition(SourcePosition source_position);
      72             : 
      73             :   // Record a safepoint with the given pointer map.
      74             :   void RecordSafepoint(ReferenceMap* references, Safepoint::Kind kind,
      75             :                        int arguments, Safepoint::DeoptMode deopt_mode);
      76             : 
      77             :  private:
      78             :   MacroAssembler* masm() { return &masm_; }
      79             :   GapResolver* resolver() { return &resolver_; }
      80             :   SafepointTableBuilder* safepoints() { return &safepoints_; }
      81    21924972 :   Zone* zone() const { return code()->zone(); }
      82             :   CompilationInfo* info() const { return info_; }
      83             : 
      84             :   // Create the FrameAccessState object. The Frame is immutable from here on.
      85             :   void CreateFrameAccessState(Frame* frame);
      86             : 
      87             :   // Architecture - specific frame finalization.
      88             :   void FinishFrame(Frame* frame);
      89             : 
      90             :   // Checks if {block} will appear directly after {current_block_} when
      91             :   // assembling code, in which case, a fall-through can be used.
      92             :   bool IsNextInAssemblyOrder(RpoNumber block) const;
      93             : 
      94             :   // Check if a heap object can be materialized by loading from a heap root,
      95             :   // which is cheaper on some platforms than materializing the actual heap
      96             :   // object constant.
      97             :   bool IsMaterializableFromRoot(Handle<HeapObject> object,
      98             :                                 Heap::RootListIndex* index_return);
      99             : 
     100             :   enum CodeGenResult { kSuccess, kTooManyDeoptimizationBailouts };
     101             : 
     102             :   // Assemble instructions for the specified block.
     103             :   CodeGenResult AssembleBlock(const InstructionBlock* block);
     104             : 
     105             :   // Assemble code for the specified instruction.
     106             :   CodeGenResult AssembleInstruction(Instruction* instr,
     107             :                                     const InstructionBlock* block);
     108             :   void AssembleGaps(Instruction* instr);
     109             : 
     110             :   // Returns true if a instruction is a tail call that needs to adjust the stack
     111             :   // pointer before execution. The stack slot index to the empty slot above the
     112             :   // adjusted stack pointer is returned in |slot|.
     113             :   bool GetSlotAboveSPBeforeTailCall(Instruction* instr, int* slot);
     114             : 
     115             :   // ===========================================================================
     116             :   // ============= Architecture-specific code generation methods. ==============
     117             :   // ===========================================================================
     118             : 
     119             :   CodeGenResult AssembleArchInstruction(Instruction* instr);
     120             :   void AssembleArchJump(RpoNumber target);
     121             :   void AssembleArchBranch(Instruction* instr, BranchInfo* branch);
     122             :   void AssembleArchBoolean(Instruction* instr, FlagsCondition condition);
     123             :   void AssembleArchTrap(Instruction* instr, FlagsCondition condition);
     124             :   void AssembleArchLookupSwitch(Instruction* instr);
     125             :   void AssembleArchTableSwitch(Instruction* instr);
     126             : 
     127             :   CodeGenResult AssembleDeoptimizerCall(int deoptimization_id,
     128             :                                         SourcePosition pos);
     129             : 
     130             :   // Generates an architecture-specific, descriptor-specific prologue
     131             :   // to set up a stack frame.
     132             :   void AssembleConstructFrame();
     133             : 
     134             :   // Generates an architecture-specific, descriptor-specific return sequence
     135             :   // to tear down a stack frame.
     136             :   void AssembleReturn(InstructionOperand* pop);
     137             : 
     138             :   void AssembleDeconstructFrame();
     139             : 
     140             :   // Generates code to manipulate the stack in preparation for a tail call.
     141             :   void AssemblePrepareTailCall();
     142             : 
     143             :   // Generates code to pop current frame if it is an arguments adaptor frame.
     144             :   void AssemblePopArgumentsAdaptorFrame(Register args_reg, Register scratch1,
     145             :                                         Register scratch2, Register scratch3);
     146             : 
     147             :   enum PushTypeFlag {
     148             :     kImmediatePush = 0x1,
     149             :     kScalarPush = 0x2,
     150             :     kFloat32Push = 0x4,
     151             :     kFloat64Push = 0x8,
     152             :     kFloatPush = kFloat32Push | kFloat64Push
     153             :   };
     154             : 
     155             :   typedef base::Flags<PushTypeFlag> PushTypeFlags;
     156             : 
     157             :   static bool IsValidPush(InstructionOperand source, PushTypeFlags push_type);
     158             : 
     159             :   // Generate a list moves from an instruction that are candidates to be turned
     160             :   // into push instructions on platforms that support them. In general, the list
     161             :   // of push candidates are moves to a set of contiguous destination
     162             :   // InstructionOperand locations on the stack that don't clobber values that
     163             :   // are needed for resolve the gap or use values generated by the gap,
     164             :   // i.e. moves that can be hoisted together before the actual gap and assembled
     165             :   // together.
     166             :   static void GetPushCompatibleMoves(Instruction* instr,
     167             :                                      PushTypeFlags push_type,
     168             :                                      ZoneVector<MoveOperands*>* pushes);
     169             : 
     170             :   // Called before a tail call |instr|'s gap moves are assembled and allows
     171             :   // gap-specific pre-processing, e.g. adjustment of the sp for tail calls that
     172             :   // need it before gap moves or conversion of certain gap moves into pushes.
     173             :   void AssembleTailCallBeforeGap(Instruction* instr,
     174             :                                  int first_unused_stack_slot);
     175             :   // Called after a tail call |instr|'s gap moves are assembled and allows
     176             :   // gap-specific post-processing, e.g. adjustment of the sp for tail calls that
     177             :   // need it after gap moves.
     178             :   void AssembleTailCallAfterGap(Instruction* instr,
     179             :                                 int first_unused_stack_slot);
     180             : 
     181             :   void FinishCode();
     182             : 
     183             :   // ===========================================================================
     184             :   // ============== Architecture-specific gap resolver methods. ================
     185             :   // ===========================================================================
     186             : 
     187             :   // Interface used by the gap resolver to emit moves and swaps.
     188             :   void AssembleMove(InstructionOperand* source,
     189             :                     InstructionOperand* destination) final;
     190             :   void AssembleSwap(InstructionOperand* source,
     191             :                     InstructionOperand* destination) final;
     192             : 
     193             :   // ===========================================================================
     194             :   // =================== Jump table construction methods. ======================
     195             :   // ===========================================================================
     196             : 
     197             :   class JumpTable;
     198             :   // Adds a jump table that is emitted after the actual code.  Returns label
     199             :   // pointing to the beginning of the table.  {targets} is assumed to be static
     200             :   // or zone allocated.
     201             :   Label* AddJumpTable(Label** targets, size_t target_count);
     202             :   // Emits a jump table.
     203             :   void AssembleJumpTable(Label** targets, size_t target_count);
     204             : 
     205             :   // ===========================================================================
     206             :   // ================== Deoptimization table construction. =====================
     207             :   // ===========================================================================
     208             : 
     209             :   void RecordCallPosition(Instruction* instr);
     210             :   void PopulateDeoptimizationData(Handle<Code> code);
     211             :   int DefineDeoptimizationLiteral(Handle<Object> literal);
     212             :   DeoptimizationEntry const& GetDeoptimizationEntry(Instruction* instr,
     213             :                                                     size_t frame_state_offset);
     214             :   DeoptimizeKind GetDeoptimizationKind(int deoptimization_id) const;
     215             :   DeoptimizeReason GetDeoptimizationReason(int deoptimization_id) const;
     216             :   int BuildTranslation(Instruction* instr, int pc_offset,
     217             :                        size_t frame_state_offset,
     218             :                        OutputFrameStateCombine state_combine);
     219             :   void BuildTranslationForFrameStateDescriptor(
     220             :       FrameStateDescriptor* descriptor, InstructionOperandIterator* iter,
     221             :       Translation* translation, OutputFrameStateCombine state_combine);
     222             :   void TranslateStateValueDescriptor(StateValueDescriptor* desc,
     223             :                                      StateValueList* nested,
     224             :                                      Translation* translation,
     225             :                                      InstructionOperandIterator* iter);
     226             :   void TranslateFrameStateDescriptorOperands(FrameStateDescriptor* desc,
     227             :                                              InstructionOperandIterator* iter,
     228             :                                              OutputFrameStateCombine combine,
     229             :                                              Translation* translation);
     230             :   void AddTranslationForOperand(Translation* translation, Instruction* instr,
     231             :                                 InstructionOperand* op, MachineType type);
     232             :   void EnsureSpaceForLazyDeopt();
     233             :   void MarkLazyDeoptSite();
     234             : 
     235             :   DeoptimizationExit* AddDeoptimizationExit(Instruction* instr,
     236             :                                             size_t frame_state_offset);
     237             : 
     238             :   // ===========================================================================
     239             : 
     240             :   class DeoptimizationState final : public ZoneObject {
     241             :    public:
     242             :     DeoptimizationState(BailoutId bailout_id, int translation_id, int pc_offset,
     243             :                         DeoptimizeKind kind, DeoptimizeReason reason)
     244             :         : bailout_id_(bailout_id),
     245             :           translation_id_(translation_id),
     246             :           pc_offset_(pc_offset),
     247             :           kind_(kind),
     248     4411712 :           reason_(reason) {}
     249             : 
     250             :     BailoutId bailout_id() const { return bailout_id_; }
     251             :     int translation_id() const { return translation_id_; }
     252             :     int pc_offset() const { return pc_offset_; }
     253             :     DeoptimizeKind kind() const { return kind_; }
     254             :     DeoptimizeReason reason() const { return reason_; }
     255             : 
     256             :    private:
     257             :     BailoutId bailout_id_;
     258             :     int translation_id_;
     259             :     int pc_offset_;
     260             :     DeoptimizeKind kind_;
     261             :     DeoptimizeReason reason_;
     262             :   };
     263             : 
     264             :   struct HandlerInfo {
     265             :     Label* handler;
     266             :     int pc_offset;
     267             :   };
     268             : 
     269             :   friend class OutOfLineCode;
     270             : 
     271             :   FrameAccessState* frame_access_state_;
     272             :   Linkage* const linkage_;
     273             :   InstructionSequence* const code_;
     274             :   UnwindingInfoWriter unwinding_info_writer_;
     275             :   CompilationInfo* const info_;
     276             :   Label* const labels_;
     277             :   Label return_label_;
     278             :   RpoNumber current_block_;
     279             :   SourcePosition current_source_position_;
     280             :   MacroAssembler masm_;
     281             :   GapResolver resolver_;
     282             :   SafepointTableBuilder safepoints_;
     283             :   ZoneVector<HandlerInfo> handlers_;
     284             :   ZoneDeque<DeoptimizationExit*> deoptimization_exits_;
     285             :   ZoneDeque<DeoptimizationState*> deoptimization_states_;
     286             :   ZoneDeque<Handle<Object>> deoptimization_literals_;
     287             :   size_t inlined_function_count_;
     288             :   TranslationBuffer translations_;
     289             :   int last_lazy_deopt_pc_;
     290             :   JumpTable* jump_tables_;
     291             :   OutOfLineCode* ools_;
     292             :   int osr_pc_offset_;
     293             :   int optimized_out_literal_id_;
     294             :   SourcePositionTableBuilder source_position_table_builder_;
     295             : };
     296             : 
     297             : }  // namespace compiler
     298             : }  // namespace internal
     299             : }  // namespace v8
     300             : 
     301             : #endif  // V8_COMPILER_CODE_GENERATOR_H

Generated by: LCOV version 1.10