LCOV - code coverage report
Current view: top level - src/objects - scope-info.h (source / functions) Hit Total Coverage
Test: app.info Lines: 5 5 100.0 %
Date: 2017-04-26 Functions: 5 5 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_OBJECTS_SCOPE_INFO_H_
       6             : #define V8_OBJECTS_SCOPE_INFO_H_
       7             : 
       8             : #include "src/globals.h"
       9             : #include "src/objects.h"
      10             : #include "src/utils.h"
      11             : 
      12             : // Has to be the last include (doesn't have include guards):
      13             : #include "src/objects/object-macros.h"
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : 
      18             : template <typename T>
      19             : class Handle;
      20             : class Isolate;
      21             : template <typename T>
      22             : class MaybeHandle;
      23             : class Scope;
      24             : class Zone;
      25             : 
      26             : // ScopeInfo represents information about different scopes of a source
      27             : // program  and the allocation of the scope's variables. Scope information
      28             : // is stored in a compressed form in ScopeInfo objects and is used
      29             : // at runtime (stack dumps, deoptimization, etc.).
      30             : 
      31             : // This object provides quick access to scope info details for runtime
      32             : // routines.
      33             : class ScopeInfo : public FixedArray {
      34             :  public:
      35             :   DECLARE_CAST(ScopeInfo)
      36             : 
      37             :   // Return the type of this scope.
      38             :   ScopeType scope_type();
      39             : 
      40             :   // Does this scope call eval?
      41             :   bool CallsEval();
      42             : 
      43             :   // Return the language mode of this scope.
      44             :   LanguageMode language_mode();
      45             : 
      46             :   // True if this scope is a (var) declaration scope.
      47             :   bool is_declaration_scope();
      48             : 
      49             :   // Does this scope make a sloppy eval call?
      50      320128 :   bool CallsSloppyEval() { return CallsEval() && is_sloppy(language_mode()); }
      51             : 
      52             :   // Return the total number of locals allocated on the stack and in the
      53             :   // context. This includes the parameters that are allocated in the context.
      54             :   int LocalCount();
      55             : 
      56             :   // Return the number of stack slots for code. This number consists of two
      57             :   // parts:
      58             :   //  1. One stack slot per stack allocated local.
      59             :   //  2. One stack slot for the function name if it is stack allocated.
      60             :   int StackSlotCount();
      61             : 
      62             :   // Return the number of context slots for code if a context is allocated. This
      63             :   // number consists of three parts:
      64             :   //  1. Size of fixed header for every context: Context::MIN_CONTEXT_SLOTS
      65             :   //  2. One context slot per context allocated local.
      66             :   //  3. One context slot for the function name if it is context allocated.
      67             :   // Parameters allocated in the context count as context allocated locals. If
      68             :   // no contexts are allocated for this scope ContextLength returns 0.
      69             :   int ContextLength();
      70             : 
      71             :   // Does this scope declare a "this" binding?
      72             :   bool HasReceiver();
      73             : 
      74             :   // Does this scope declare a "this" binding, and the "this" binding is stack-
      75             :   // or context-allocated?
      76             :   bool HasAllocatedReceiver();
      77             : 
      78             :   // Does this scope declare a "new.target" binding?
      79             :   bool HasNewTarget();
      80             : 
      81             :   // Is this scope the scope of a named function expression?
      82             :   bool HasFunctionName();
      83             : 
      84             :   // Return if this has context allocated locals.
      85             :   bool HasHeapAllocatedLocals();
      86             : 
      87             :   // Return if contexts are allocated for this scope.
      88             :   bool HasContext();
      89             : 
      90             :   // Return if this is a function scope with "use asm".
      91     3613936 :   inline bool IsAsmModule() { return AsmModuleField::decode(Flags()); }
      92             : 
      93             :   // Return if this is a nested function within an asm module scope.
      94     3314894 :   inline bool IsAsmFunction() { return AsmFunctionField::decode(Flags()); }
      95             : 
      96             :   inline bool HasSimpleParameters() {
      97       97580 :     return HasSimpleParametersField::decode(Flags());
      98             :   }
      99             : 
     100             :   // Return the function_name if present.
     101             :   String* FunctionName();
     102             : 
     103             :   ModuleInfo* ModuleDescriptorInfo();
     104             : 
     105             :   // Return the name of the given parameter.
     106             :   String* ParameterName(int var);
     107             : 
     108             :   // Return the name of the given local.
     109             :   String* LocalName(int var);
     110             : 
     111             :   // Return the name of the given stack local.
     112             :   String* StackLocalName(int var);
     113             : 
     114             :   // Return the name of the given stack local.
     115             :   int StackLocalIndex(int var);
     116             : 
     117             :   // Return the name of the given context local.
     118             :   String* ContextLocalName(int var);
     119             : 
     120             :   // Return the mode of the given context local.
     121             :   VariableMode ContextLocalMode(int var);
     122             : 
     123             :   // Return the initialization flag of the given context local.
     124             :   InitializationFlag ContextLocalInitFlag(int var);
     125             : 
     126             :   // Return the initialization flag of the given context local.
     127             :   MaybeAssignedFlag ContextLocalMaybeAssignedFlag(int var);
     128             : 
     129             :   // Return true if this local was introduced by the compiler, and should not be
     130             :   // exposed to the user in a debugger.
     131             :   static bool VariableIsSynthetic(String* name);
     132             : 
     133             :   // Lookup support for serialized scope info. Returns the
     134             :   // the stack slot index for a given slot name if the slot is
     135             :   // present; otherwise returns a value < 0. The name must be an internalized
     136             :   // string.
     137             :   int StackSlotIndex(String* name);
     138             : 
     139             :   // Lookup support for serialized scope info. Returns the local context slot
     140             :   // index for a given slot name if the slot is present; otherwise
     141             :   // returns a value < 0. The name must be an internalized string.
     142             :   // If the slot is present and mode != NULL, sets *mode to the corresponding
     143             :   // mode for that variable.
     144             :   static int ContextSlotIndex(Handle<ScopeInfo> scope_info, Handle<String> name,
     145             :                               VariableMode* mode, InitializationFlag* init_flag,
     146             :                               MaybeAssignedFlag* maybe_assigned_flag);
     147             : 
     148             :   // Lookup metadata of a MODULE-allocated variable.  Return 0 if there is no
     149             :   // module variable with the given name (the index value of a MODULE variable
     150             :   // is never 0).
     151             :   int ModuleIndex(Handle<String> name, VariableMode* mode,
     152             :                   InitializationFlag* init_flag,
     153             :                   MaybeAssignedFlag* maybe_assigned_flag);
     154             : 
     155             :   // Lookup the name of a certain context slot by its index.
     156             :   String* ContextSlotName(int slot_index);
     157             : 
     158             :   // Lookup support for serialized scope info. Returns the
     159             :   // parameter index for a given parameter name if the parameter is present;
     160             :   // otherwise returns a value < 0. The name must be an internalized string.
     161             :   int ParameterIndex(String* name);
     162             : 
     163             :   // Lookup support for serialized scope info. Returns the function context
     164             :   // slot index if the function name is present and context-allocated (named
     165             :   // function expressions, only), otherwise returns a value < 0. The name
     166             :   // must be an internalized string.
     167             :   int FunctionContextSlotIndex(String* name);
     168             : 
     169             :   // Lookup support for serialized scope info.  Returns the receiver context
     170             :   // slot index if scope has a "this" binding, and the binding is
     171             :   // context-allocated.  Otherwise returns a value < 0.
     172             :   int ReceiverContextSlotIndex();
     173             : 
     174             :   FunctionKind function_kind();
     175             : 
     176             :   // Returns true if this ScopeInfo is linked to a outer ScopeInfo.
     177             :   bool HasOuterScopeInfo();
     178             : 
     179             :   // Returns true if this ScopeInfo was created for a debug-evaluate scope.
     180             :   bool IsDebugEvaluateScope();
     181             : 
     182             :   // Can be used to mark a ScopeInfo that looks like a with-scope as actually
     183             :   // being a debug-evaluate scope.
     184             :   void SetIsDebugEvaluateScope();
     185             : 
     186             :   // Return the outer ScopeInfo if present.
     187             :   ScopeInfo* OuterScopeInfo();
     188             : 
     189             : #ifdef DEBUG
     190             :   bool Equals(ScopeInfo* other) const;
     191             : #endif
     192             : 
     193             :   static Handle<ScopeInfo> Create(Isolate* isolate, Zone* zone, Scope* scope,
     194             :                                   MaybeHandle<ScopeInfo> outer_scope);
     195             :   static Handle<ScopeInfo> CreateForWithScope(
     196             :       Isolate* isolate, MaybeHandle<ScopeInfo> outer_scope);
     197             :   static Handle<ScopeInfo> CreateGlobalThisBinding(Isolate* isolate);
     198             : 
     199             :   // Serializes empty scope info.
     200             :   V8_EXPORT_PRIVATE static ScopeInfo* Empty(Isolate* isolate);
     201             : 
     202             : #ifdef DEBUG
     203             :   void Print();
     204             : #endif
     205             : 
     206             : // The layout of the static part of a ScopeInfo is as follows. Each entry is
     207             : // numeric and occupies one array slot.
     208             : // 1. A set of properties of the scope.
     209             : // 2. The number of parameters. For non-function scopes this is 0.
     210             : // 3. The number of non-parameter variables allocated on the stack.
     211             : // 4. The number of non-parameter and parameter variables allocated in the
     212             : //    context.
     213             : #define FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(V) \
     214             :   V(Flags)                                   \
     215             :   V(ParameterCount)                          \
     216             :   V(StackLocalCount)                         \
     217             :   V(ContextLocalCount)
     218             : 
     219             : #define FIELD_ACCESSORS(name)                                             \
     220             :   inline void Set##name(int value) { set(k##name, Smi::FromInt(value)); } \
     221             :   inline int name() {                                                     \
     222             :     if (length() > 0) {                                                   \
     223             :       return Smi::cast(get(k##name))->value();                            \
     224             :     } else {                                                              \
     225             :       return 0;                                                           \
     226             :     }                                                                     \
     227             :   }
     228             : 
     229   455181452 :   FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(FIELD_ACCESSORS)
     230             : #undef FIELD_ACCESSORS
     231             : 
     232             :   enum {
     233             : #define DECL_INDEX(name) k##name,
     234             :     FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(DECL_INDEX)
     235             : #undef DECL_INDEX
     236             :         kVariablePartIndex
     237             :   };
     238             : 
     239             :  private:
     240             :   // The layout of the variable part of a ScopeInfo is as follows:
     241             :   // 1. ParameterNames:
     242             :   //    This part stores the names of the parameters for function scopes. One
     243             :   //    slot is used per parameter, so in total this part occupies
     244             :   //    ParameterCount() slots in the array. For other scopes than function
     245             :   //    scopes ParameterCount() is 0.
     246             :   // 2. StackLocalFirstSlot:
     247             :   //    Index of a first stack slot for stack local. Stack locals belonging to
     248             :   //    this scope are located on a stack at slots starting from this index.
     249             :   // 3. StackLocalNames:
     250             :   //    Contains the names of local variables that are allocated on the stack,
     251             :   //    in increasing order of the stack slot index. First local variable has a
     252             :   //    stack slot index defined in StackLocalFirstSlot (point 2 above).
     253             :   //    One slot is used per stack local, so in total this part occupies
     254             :   //    StackLocalCount() slots in the array.
     255             :   // 4. ContextLocalNames:
     256             :   //    Contains the names of local variables and parameters that are allocated
     257             :   //    in the context. They are stored in increasing order of the context slot
     258             :   //    index starting with Context::MIN_CONTEXT_SLOTS. One slot is used per
     259             :   //    context local, so in total this part occupies ContextLocalCount() slots
     260             :   //    in the array.
     261             :   // 5. ContextLocalInfos:
     262             :   //    Contains the variable modes and initialization flags corresponding to
     263             :   //    the context locals in ContextLocalNames. One slot is used per
     264             :   //    context local, so in total this part occupies ContextLocalCount()
     265             :   //    slots in the array.
     266             :   // 6. ReceiverInfo:
     267             :   //    If the scope binds a "this" value, one slot is reserved to hold the
     268             :   //    context or stack slot index for the variable.
     269             :   // 7. FunctionNameInfo:
     270             :   //    If the scope belongs to a named function expression this part contains
     271             :   //    information about the function variable. It always occupies two array
     272             :   //    slots:  a. The name of the function variable.
     273             :   //            b. The context or stack slot index for the variable.
     274             :   // 8. OuterScopeInfoIndex:
     275             :   //    The outer scope's ScopeInfo or the hole if there's none.
     276             :   // 9. ModuleInfo, ModuleVariableCount, and ModuleVariables:
     277             :   //    For a module scope, this part contains the ModuleInfo, the number of
     278             :   //    MODULE-allocated variables, and the metadata of those variables.  For
     279             :   //    non-module scopes it is empty.
     280             :   int ParameterNamesIndex();
     281             :   int StackLocalFirstSlotIndex();
     282             :   int StackLocalNamesIndex();
     283             :   int ContextLocalNamesIndex();
     284             :   int ContextLocalInfosIndex();
     285             :   int ReceiverInfoIndex();
     286             :   int FunctionNameInfoIndex();
     287             :   int OuterScopeInfoIndex();
     288             :   int ModuleInfoIndex();
     289             :   int ModuleVariableCountIndex();
     290             :   int ModuleVariablesIndex();
     291             : 
     292             :   int Lookup(Handle<String> name, int start, int end, VariableMode* mode,
     293             :              VariableLocation* location, InitializationFlag* init_flag,
     294             :              MaybeAssignedFlag* maybe_assigned_flag);
     295             : 
     296             :   // Get metadata of i-th MODULE-allocated variable, where 0 <= i <
     297             :   // ModuleVariableCount.  The metadata is returned via out-arguments, which may
     298             :   // be nullptr if the corresponding information is not requested
     299             :   void ModuleVariable(int i, String** name, int* index,
     300             :                       VariableMode* mode = nullptr,
     301             :                       InitializationFlag* init_flag = nullptr,
     302             :                       MaybeAssignedFlag* maybe_assigned_flag = nullptr);
     303             : 
     304             :   // Used for the function name variable for named function expressions, and for
     305             :   // the receiver.
     306             :   enum VariableAllocationInfo { NONE, STACK, CONTEXT, UNUSED };
     307             : 
     308             :   // Properties of scopes.
     309             :   class ScopeTypeField : public BitField<ScopeType, 0, 4> {};
     310             :   class CallsEvalField : public BitField<bool, ScopeTypeField::kNext, 1> {};
     311             :   STATIC_ASSERT(LANGUAGE_END == 2);
     312             :   class LanguageModeField
     313             :       : public BitField<LanguageMode, CallsEvalField::kNext, 1> {};
     314             :   class DeclarationScopeField
     315             :       : public BitField<bool, LanguageModeField::kNext, 1> {};
     316             :   class ReceiverVariableField
     317             :       : public BitField<VariableAllocationInfo, DeclarationScopeField::kNext,
     318             :                         2> {};
     319             :   class HasNewTargetField
     320             :       : public BitField<bool, ReceiverVariableField::kNext, 1> {};
     321             :   class FunctionVariableField
     322             :       : public BitField<VariableAllocationInfo, HasNewTargetField::kNext, 2> {};
     323             :   class AsmModuleField
     324             :       : public BitField<bool, FunctionVariableField::kNext, 1> {};
     325             :   class AsmFunctionField : public BitField<bool, AsmModuleField::kNext, 1> {};
     326             :   class HasSimpleParametersField
     327             :       : public BitField<bool, AsmFunctionField::kNext, 1> {};
     328             :   class FunctionKindField
     329             :       : public BitField<FunctionKind, HasSimpleParametersField::kNext, 10> {};
     330             :   class HasOuterScopeInfoField
     331             :       : public BitField<bool, FunctionKindField::kNext, 1> {};
     332             :   class IsDebugEvaluateScopeField
     333             :       : public BitField<bool, HasOuterScopeInfoField::kNext, 1> {};
     334             : 
     335             :   // Properties of variables.
     336             :   class VariableModeField : public BitField<VariableMode, 0, 3> {};
     337             :   class InitFlagField : public BitField<InitializationFlag, 3, 1> {};
     338             :   class MaybeAssignedFlagField : public BitField<MaybeAssignedFlag, 4, 1> {};
     339             : 
     340             :   friend class ScopeIterator;
     341             : };
     342             : 
     343             : }  // namespace internal
     344             : }  // namespace v8
     345             : 
     346             : #include "src/objects/object-macros-undef.h"
     347             : 
     348             : #endif  // V8_OBJECTS_SCOPE_INFO_H_

Generated by: LCOV version 1.10