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

          Line data    Source code
       1             : // Copyright 2015 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_INTERPRETER_BYTECODE_GENERATOR_H_
       6             : #define V8_INTERPRETER_BYTECODE_GENERATOR_H_
       7             : 
       8             : #include "src/ast/ast.h"
       9             : #include "src/interpreter/bytecode-array-builder.h"
      10             : #include "src/interpreter/bytecode-label.h"
      11             : #include "src/interpreter/bytecode-register.h"
      12             : #include "src/interpreter/bytecodes.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : class AstStringConstants;
      18             : class CompilationInfo;
      19             : 
      20             : namespace interpreter {
      21             : 
      22             : class GlobalDeclarationsBuilder;
      23             : class LoopBuilder;
      24             : 
      25             : class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
      26             :  public:
      27             :   explicit BytecodeGenerator(CompilationInfo* info);
      28             : 
      29             :   void GenerateBytecode(uintptr_t stack_limit);
      30             :   Handle<BytecodeArray> FinalizeBytecode(Isolate* isolate);
      31             : 
      32             : #define DECLARE_VISIT(type) void Visit##type(type* node);
      33             :   AST_NODE_LIST(DECLARE_VISIT)
      34             : #undef DECLARE_VISIT
      35             : 
      36             :   // Visiting function for declarations list and statements are overridden.
      37             :   void VisitDeclarations(Declaration::List* declarations);
      38             :   void VisitStatements(ZoneList<Statement*>* statments);
      39             : 
      40             :  private:
      41             :   class ContextScope;
      42             :   class ControlScope;
      43             :   class ControlScopeForBreakable;
      44             :   class ControlScopeForIteration;
      45             :   class ControlScopeForTopLevel;
      46             :   class ControlScopeForTryCatch;
      47             :   class ControlScopeForTryFinally;
      48             :   class CurrentScope;
      49             :   class ExpressionResultScope;
      50             :   class EffectResultScope;
      51             :   class GlobalDeclarationsBuilder;
      52             :   class RegisterAllocationScope;
      53             :   class TestResultScope;
      54             :   class ValueResultScope;
      55             : 
      56             :   using ToBooleanMode = BytecodeArrayBuilder::ToBooleanMode;
      57             : 
      58             :   enum class TestFallthrough { kThen, kElse, kNone };
      59             :   enum class TypeHint { kAny, kBoolean };
      60             : 
      61             :   void GenerateBytecodeBody();
      62             :   void AllocateDeferredConstants(Isolate* isolate);
      63             : 
      64   257865478 :   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
      65             : 
      66             :   // Dispatched from VisitBinaryOperation.
      67             :   void VisitArithmeticExpression(BinaryOperation* binop);
      68             :   void VisitCommaExpression(BinaryOperation* binop);
      69             :   void VisitLogicalOrExpression(BinaryOperation* binop);
      70             :   void VisitLogicalAndExpression(BinaryOperation* binop);
      71             : 
      72             :   // Dispatched from VisitUnaryOperation.
      73             :   void VisitVoid(UnaryOperation* expr);
      74             :   void VisitTypeOf(UnaryOperation* expr);
      75             :   void VisitNot(UnaryOperation* expr);
      76             :   void VisitDelete(UnaryOperation* expr);
      77             : 
      78             :   // Visits a typeof expression for the value on which to perform the typeof.
      79             :   void VisitForTypeOfValue(Expression* expr);
      80             : 
      81             :   // Used by flow control routines to evaluate loop condition.
      82             :   void VisitCondition(Expression* expr);
      83             : 
      84             :   // Visit the arguments expressions in |args| and store them in |args_regs|,
      85             :   // growing |args_regs| for each argument visited.
      86             :   void VisitArguments(ZoneList<Expression*>* args, RegisterList* arg_regs);
      87             : 
      88             :   // Visit a keyed super property load. The optional
      89             :   // |opt_receiver_out| register will have the receiver stored to it
      90             :   // if it's a valid register. The loaded value is placed in the
      91             :   // accumulator.
      92             :   void VisitKeyedSuperPropertyLoad(Property* property,
      93             :                                    Register opt_receiver_out);
      94             : 
      95             :   // Visit a named super property load. The optional
      96             :   // |opt_receiver_out| register will have the receiver stored to it
      97             :   // if it's a valid register. The loaded value is placed in the
      98             :   // accumulator.
      99             :   void VisitNamedSuperPropertyLoad(Property* property,
     100             :                                    Register opt_receiver_out);
     101             : 
     102             :   void VisitPropertyLoad(Register obj, Property* expr);
     103             :   void VisitPropertyLoadForRegister(Register obj, Property* expr,
     104             :                                     Register destination);
     105             : 
     106             :   void BuildVariableLoad(Variable* variable, FeedbackSlot slot,
     107             :                          HoleCheckMode hole_check_mode,
     108             :                          TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
     109             :   void BuildVariableLoadForAccumulatorValue(
     110             :       Variable* variable, FeedbackSlot slot, HoleCheckMode hole_check_mode,
     111             :       TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
     112             :   void BuildVariableAssignment(Variable* variable, Token::Value op,
     113             :                                FeedbackSlot slot,
     114             :                                HoleCheckMode hole_check_mode);
     115             :   void BuildLiteralCompareNil(Token::Value compare_op, NilValue nil);
     116             :   void BuildReturn();
     117             :   void BuildAsyncReturn();
     118             :   void BuildAsyncGeneratorReturn();
     119             :   void BuildReThrow();
     120             :   void BuildAbort(BailoutReason bailout_reason);
     121             :   void BuildThrowIfHole(Variable* variable);
     122             :   void BuildThrowReferenceError(const AstRawString* name);
     123             :   void BuildHoleCheckForVariableAssignment(Variable* variable, Token::Value op);
     124             : 
     125             :   // Build jump to targets[value], where
     126             :   // start_index <= value < start_index + size.
     127             :   void BuildIndexedJump(Register value, size_t start_index, size_t size,
     128             :                         ZoneVector<BytecodeLabel>& targets);
     129             : 
     130             :   void BuildNewLocalActivationContext();
     131             :   void BuildLocalActivationContextInitialization();
     132             :   void BuildNewLocalBlockContext(Scope* scope);
     133             :   void BuildNewLocalCatchContext(Scope* scope);
     134             :   void BuildNewLocalWithContext(Scope* scope);
     135             : 
     136             :   void VisitGeneratorPrologue();
     137             : 
     138             :   void VisitArgumentsObject(Variable* variable);
     139             :   void VisitRestArgumentsArray(Variable* rest);
     140             :   void VisitCallSuper(Call* call);
     141             :   void VisitClassLiteralProperties(ClassLiteral* expr, Register constructor,
     142             :                                    Register prototype);
     143             :   void BuildClassLiteralNameProperty(ClassLiteral* expr, Register constructor);
     144             :   void VisitThisFunctionVariable(Variable* variable);
     145             :   void VisitNewTargetVariable(Variable* variable);
     146             :   void VisitBlockDeclarationsAndStatements(Block* stmt);
     147             :   void VisitFunctionClosureForContext();
     148             :   void VisitSetHomeObject(Register value, Register home_object,
     149             :                           LiteralProperty* property, int slot_number = 0);
     150             :   void VisitObjectLiteralAccessor(Register home_object,
     151             :                                   ObjectLiteralProperty* property,
     152             :                                   Register value_out);
     153             :   void VisitForInAssignment(Expression* expr, FeedbackSlot slot);
     154             :   void VisitModuleNamespaceImports();
     155             : 
     156             :   // Visit the header/body of a loop iteration.
     157             :   void VisitIterationHeader(IterationStatement* stmt,
     158             :                             LoopBuilder* loop_builder);
     159             :   void VisitIterationBody(IterationStatement* stmt, LoopBuilder* loop_builder);
     160             : 
     161             :   // Visit a statement and switch scopes, the context is in the accumulator.
     162             :   void VisitInScope(Statement* stmt, Scope* scope);
     163             : 
     164             :   void BuildPushUndefinedIntoRegisterList(RegisterList* reg_list);
     165             : 
     166             :   void BuildLoadPropertyKey(LiteralProperty* property, Register out_reg);
     167             : 
     168             :   // Visitors for obtaining expression result in the accumulator, in a
     169             :   // register, or just getting the effect. Some visitors return a TypeHint which
     170             :   // specifies the type of the result of the visited expression.
     171             :   TypeHint VisitForAccumulatorValue(Expression* expr);
     172             :   void VisitForAccumulatorValueOrTheHole(Expression* expr);
     173             :   MUST_USE_RESULT Register VisitForRegisterValue(Expression* expr);
     174             :   void VisitForRegisterValue(Expression* expr, Register destination);
     175             :   void VisitAndPushIntoRegisterList(Expression* expr, RegisterList* reg_list);
     176             :   void VisitForEffect(Expression* expr);
     177             :   void VisitForTest(Expression* expr, BytecodeLabels* then_labels,
     178             :                     BytecodeLabels* else_labels, TestFallthrough fallthrough);
     179             : 
     180             :   // Returns the runtime function id for a store to super for the function's
     181             :   // language mode.
     182             :   inline Runtime::FunctionId StoreToSuperRuntimeId();
     183             :   inline Runtime::FunctionId StoreKeyedToSuperRuntimeId();
     184             : 
     185             :   ToBooleanMode ToBooleanModeFromTypeHint(TypeHint type_hint);
     186             : 
     187             :   inline BytecodeArrayBuilder* builder() const { return builder_; }
     188             :   inline Zone* zone() const { return zone_; }
     189             :   inline DeclarationScope* closure_scope() const { return closure_scope_; }
     190             :   inline CompilationInfo* info() const { return info_; }
     191             :   inline const AstStringConstants* ast_string_constants() const {
     192             :     return ast_string_constants_;
     193             :   }
     194             : 
     195             :   inline Scope* current_scope() const { return current_scope_; }
     196      631900 :   inline void set_current_scope(Scope* scope) { current_scope_ = scope; }
     197             : 
     198             :   inline ControlScope* execution_control() const { return execution_control_; }
     199             :   inline void set_execution_control(ControlScope* scope) {
     200    15298121 :     execution_control_ = scope;
     201             :   }
     202             :   inline ContextScope* execution_context() const { return execution_context_; }
     203             :   inline void set_execution_context(ContextScope* context) {
     204     4909519 :     execution_context_ = context;
     205             :   }
     206             :   inline void set_execution_result(ExpressionResultScope* execution_result) {
     207    87424205 :     execution_result_ = execution_result;
     208             :   }
     209             :   ExpressionResultScope* execution_result() const { return execution_result_; }
     210   172250266 :   BytecodeRegisterAllocator* register_allocator() const {
     211             :     return builder()->register_allocator();
     212             :   }
     213             : 
     214             :   GlobalDeclarationsBuilder* globals_builder() {
     215             :     DCHECK_NOT_NULL(globals_builder_);
     216             :     return globals_builder_;
     217             :   }
     218             :   inline LanguageMode language_mode() const;
     219             :   int feedback_index(FeedbackSlot slot) const;
     220             : 
     221             :   Zone* zone_;
     222             :   BytecodeArrayBuilder* builder_;
     223             :   CompilationInfo* info_;
     224             :   const AstStringConstants* ast_string_constants_;
     225             :   DeclarationScope* closure_scope_;
     226             :   Scope* current_scope_;
     227             : 
     228             :   GlobalDeclarationsBuilder* globals_builder_;
     229             :   ZoneVector<GlobalDeclarationsBuilder*> global_declarations_;
     230             :   ZoneVector<std::pair<FunctionLiteral*, size_t>> function_literals_;
     231             :   ZoneVector<std::pair<NativeFunctionLiteral*, size_t>>
     232             :       native_function_literals_;
     233             :   ZoneVector<std::pair<ObjectLiteral*, size_t>> object_literals_;
     234             :   ZoneVector<std::pair<ArrayLiteral*, size_t>> array_literals_;
     235             : 
     236             :   ControlScope* execution_control_;
     237             :   ContextScope* execution_context_;
     238             :   ExpressionResultScope* execution_result_;
     239             : 
     240             :   ZoneVector<BytecodeLabel> generator_resume_points_;
     241             :   Register generator_state_;
     242             :   int loop_depth_;
     243             : };
     244             : 
     245             : }  // namespace interpreter
     246             : }  // namespace internal
     247             : }  // namespace v8
     248             : 
     249             : #endif  // V8_INTERPRETER_BYTECODE_GENERATOR_H_

Generated by: LCOV version 1.10