Home | History | Annotate | Download | only in src
      1 // Copyright 2012 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #ifndef V8_V8GLOBALS_H_
     29 #define V8_V8GLOBALS_H_
     30 
     31 #include "globals.h"
     32 #include "checks.h"
     33 
     34 namespace v8 {
     35 namespace internal {
     36 
     37 // This file contains constants and global declarations related to the
     38 // V8 system.
     39 
     40 // Mask for the sign bit in a smi.
     41 const intptr_t kSmiSignMask = kIntptrSignBit;
     42 
     43 const int kObjectAlignmentBits = kPointerSizeLog2;
     44 const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits;
     45 const intptr_t kObjectAlignmentMask = kObjectAlignment - 1;
     46 
     47 // Desired alignment for pointers.
     48 const intptr_t kPointerAlignment = (1 << kPointerSizeLog2);
     49 const intptr_t kPointerAlignmentMask = kPointerAlignment - 1;
     50 
     51 // Desired alignment for double values.
     52 const intptr_t kDoubleAlignment = 8;
     53 const intptr_t kDoubleAlignmentMask = kDoubleAlignment - 1;
     54 
     55 // Desired alignment for generated code is 32 bytes (to improve cache line
     56 // utilization).
     57 const int kCodeAlignmentBits = 5;
     58 const intptr_t kCodeAlignment = 1 << kCodeAlignmentBits;
     59 const intptr_t kCodeAlignmentMask = kCodeAlignment - 1;
     60 
     61 // Tag information for Failure.
     62 const int kFailureTag = 3;
     63 const int kFailureTagSize = 2;
     64 const intptr_t kFailureTagMask = (1 << kFailureTagSize) - 1;
     65 
     66 
     67 // Zap-value: The value used for zapping dead objects.
     68 // Should be a recognizable hex value tagged as a failure.
     69 #ifdef V8_HOST_ARCH_64_BIT
     70 const Address kZapValue =
     71     reinterpret_cast<Address>(V8_UINT64_C(0xdeadbeedbeadbeef));
     72 const Address kHandleZapValue =
     73     reinterpret_cast<Address>(V8_UINT64_C(0x1baddead0baddeaf));
     74 const Address kGlobalHandleZapValue =
     75     reinterpret_cast<Address>(V8_UINT64_C(0x1baffed00baffedf));
     76 const Address kFromSpaceZapValue =
     77     reinterpret_cast<Address>(V8_UINT64_C(0x1beefdad0beefdaf));
     78 const uint64_t kDebugZapValue = V8_UINT64_C(0xbadbaddbbadbaddb);
     79 const uint64_t kSlotsZapValue = V8_UINT64_C(0xbeefdeadbeefdeef);
     80 const uint64_t kFreeListZapValue = 0xfeed1eaffeed1eaf;
     81 #else
     82 const Address kZapValue = reinterpret_cast<Address>(0xdeadbeef);
     83 const Address kHandleZapValue = reinterpret_cast<Address>(0xbaddeaf);
     84 const Address kGlobalHandleZapValue = reinterpret_cast<Address>(0xbaffedf);
     85 const Address kFromSpaceZapValue = reinterpret_cast<Address>(0xbeefdaf);
     86 const uint32_t kSlotsZapValue = 0xbeefdeef;
     87 const uint32_t kDebugZapValue = 0xbadbaddb;
     88 const uint32_t kFreeListZapValue = 0xfeed1eaf;
     89 #endif
     90 
     91 const int kCodeZapValue = 0xbadc0de;
     92 
     93 // Number of bits to represent the page size for paged spaces. The value of 20
     94 // gives 1Mb bytes per page.
     95 const int kPageSizeBits = 20;
     96 
     97 // On Intel architecture, cache line size is 64 bytes.
     98 // On ARM it may be less (32 bytes), but as far this constant is
     99 // used for aligning data, it doesn't hurt to align on a greater value.
    100 const int kProcessorCacheLineSize = 64;
    101 
    102 // Constants relevant to double precision floating point numbers.
    103 // If looking only at the top 32 bits, the QNaN mask is bits 19 to 30.
    104 const uint32_t kQuietNaNHighBitsMask = 0xfff << (51 - 32);
    105 
    106 
    107 // -----------------------------------------------------------------------------
    108 // Forward declarations for frequently used classes
    109 
    110 class AccessorInfo;
    111 class Allocation;
    112 class Arguments;
    113 class Assembler;
    114 class Code;
    115 class CodeGenerator;
    116 class CodeStub;
    117 class Context;
    118 class Debug;
    119 class Debugger;
    120 class DebugInfo;
    121 class Descriptor;
    122 class DescriptorArray;
    123 class TransitionArray;
    124 class ExternalReference;
    125 class FixedArray;
    126 class FunctionTemplateInfo;
    127 class MemoryChunk;
    128 class SeededNumberDictionary;
    129 class UnseededNumberDictionary;
    130 class NameDictionary;
    131 template <typename T> class Handle;
    132 class Heap;
    133 class HeapObject;
    134 class IC;
    135 class InterceptorInfo;
    136 class JSReceiver;
    137 class JSArray;
    138 class JSFunction;
    139 class JSObject;
    140 class LargeObjectSpace;
    141 class LookupResult;
    142 class MacroAssembler;
    143 class Map;
    144 class MapSpace;
    145 class MarkCompactCollector;
    146 class NewSpace;
    147 class Object;
    148 class MaybeObject;
    149 class OldSpace;
    150 class Foreign;
    151 class Scope;
    152 class ScopeInfo;
    153 class Script;
    154 class Smi;
    155 template <typename Config, class Allocator = FreeStoreAllocationPolicy>
    156     class SplayTree;
    157 class String;
    158 class Name;
    159 class Struct;
    160 class Variable;
    161 class RelocInfo;
    162 class Deserializer;
    163 class MessageLocation;
    164 class VirtualMemory;
    165 class Mutex;
    166 
    167 typedef bool (*WeakSlotCallback)(Object** pointer);
    168 
    169 typedef bool (*WeakSlotCallbackWithHeap)(Heap* heap, Object** pointer);
    170 
    171 // -----------------------------------------------------------------------------
    172 // Miscellaneous
    173 
    174 // NOTE: SpaceIterator depends on AllocationSpace enumeration values being
    175 // consecutive.
    176 enum AllocationSpace {
    177   NEW_SPACE,            // Semispaces collected with copying collector.
    178   OLD_POINTER_SPACE,    // May contain pointers to new space.
    179   OLD_DATA_SPACE,       // Must not have pointers to new space.
    180   CODE_SPACE,           // No pointers to new space, marked executable.
    181   MAP_SPACE,            // Only and all map objects.
    182   CELL_SPACE,           // Only and all cell objects.
    183   PROPERTY_CELL_SPACE,  // Only and all global property cell objects.
    184   LO_SPACE,             // Promoted large objects.
    185 
    186   FIRST_SPACE = NEW_SPACE,
    187   LAST_SPACE = LO_SPACE,
    188   FIRST_PAGED_SPACE = OLD_POINTER_SPACE,
    189   LAST_PAGED_SPACE = PROPERTY_CELL_SPACE
    190 };
    191 const int kSpaceTagSize = 3;
    192 const int kSpaceTagMask = (1 << kSpaceTagSize) - 1;
    193 
    194 
    195 // A flag that indicates whether objects should be pretenured when
    196 // allocated (allocated directly into the old generation) or not
    197 // (allocated in the young generation if the object size and type
    198 // allows).
    199 enum PretenureFlag { NOT_TENURED, TENURED };
    200 
    201 enum GarbageCollector { SCAVENGER, MARK_COMPACTOR };
    202 
    203 enum Executability { NOT_EXECUTABLE, EXECUTABLE };
    204 
    205 enum VisitMode {
    206   VISIT_ALL,
    207   VISIT_ALL_IN_SCAVENGE,
    208   VISIT_ALL_IN_SWEEP_NEWSPACE,
    209   VISIT_ONLY_STRONG
    210 };
    211 
    212 // Flag indicating whether code is built into the VM (one of the natives files).
    213 enum NativesFlag { NOT_NATIVES_CODE, NATIVES_CODE };
    214 
    215 
    216 // A CodeDesc describes a buffer holding instructions and relocation
    217 // information. The instructions start at the beginning of the buffer
    218 // and grow forward, the relocation information starts at the end of
    219 // the buffer and grows backward.
    220 //
    221 //  |<--------------- buffer_size ---------------->|
    222 //  |<-- instr_size -->|        |<-- reloc_size -->|
    223 //  +==================+========+==================+
    224 //  |   instructions   |  free  |    reloc info    |
    225 //  +==================+========+==================+
    226 //  ^
    227 //  |
    228 //  buffer
    229 
    230 struct CodeDesc {
    231   byte* buffer;
    232   int buffer_size;
    233   int instr_size;
    234   int reloc_size;
    235   Assembler* origin;
    236 };
    237 
    238 
    239 // Callback function used for iterating objects in heap spaces,
    240 // for example, scanning heap objects.
    241 typedef int (*HeapObjectCallback)(HeapObject* obj);
    242 
    243 
    244 // Callback function used for checking constraints when copying/relocating
    245 // objects. Returns true if an object can be copied/relocated from its
    246 // old_addr to a new_addr.
    247 typedef bool (*ConstraintCallback)(Address new_addr, Address old_addr);
    248 
    249 
    250 // Callback function on inline caches, used for iterating over inline caches
    251 // in compiled code.
    252 typedef void (*InlineCacheCallback)(Code* code, Address ic);
    253 
    254 
    255 // State for inline cache call sites. Aliased as IC::State.
    256 enum InlineCacheState {
    257   // Has never been executed.
    258   UNINITIALIZED,
    259   // Has been executed but monomorhic state has been delayed.
    260   PREMONOMORPHIC,
    261   // Has been executed and only one receiver type has been seen.
    262   MONOMORPHIC,
    263   // Like MONOMORPHIC but check failed due to prototype.
    264   MONOMORPHIC_PROTOTYPE_FAILURE,
    265   // Multiple receiver types have been seen.
    266   POLYMORPHIC,
    267   // Many receiver types have been seen.
    268   MEGAMORPHIC,
    269   // A generic handler is installed and no extra typefeedback is recorded.
    270   GENERIC,
    271   // Special state for debug break or step in prepare stubs.
    272   DEBUG_STUB
    273 };
    274 
    275 
    276 enum CheckType {
    277   RECEIVER_MAP_CHECK,
    278   STRING_CHECK,
    279   SYMBOL_CHECK,
    280   NUMBER_CHECK,
    281   BOOLEAN_CHECK
    282 };
    283 
    284 
    285 enum CallFunctionFlags {
    286   NO_CALL_FUNCTION_FLAGS = 0,
    287   // Receiver might implicitly be the global objects. If it is, the
    288   // hole is passed to the call function stub.
    289   RECEIVER_MIGHT_BE_IMPLICIT = 1 << 0,
    290   // The call target is cached in the instruction stream.
    291   RECORD_CALL_TARGET = 1 << 1
    292 };
    293 
    294 
    295 enum InlineCacheHolderFlag {
    296   OWN_MAP,  // For fast properties objects.
    297   PROTOTYPE_MAP  // For slow properties objects (except GlobalObjects).
    298 };
    299 
    300 
    301 // The Store Buffer (GC).
    302 typedef enum {
    303   kStoreBufferFullEvent,
    304   kStoreBufferStartScanningPagesEvent,
    305   kStoreBufferScanningPageEvent
    306 } StoreBufferEvent;
    307 
    308 
    309 typedef void (*StoreBufferCallback)(Heap* heap,
    310                                     MemoryChunk* page,
    311                                     StoreBufferEvent event);
    312 
    313 
    314 // Union used for fast testing of specific double values.
    315 union DoubleRepresentation {
    316   double  value;
    317   int64_t bits;
    318   DoubleRepresentation(double x) { value = x; }
    319 };
    320 
    321 
    322 // Union used for customized checking of the IEEE double types
    323 // inlined within v8 runtime, rather than going to the underlying
    324 // platform headers and libraries
    325 union IeeeDoubleLittleEndianArchType {
    326   double d;
    327   struct {
    328     unsigned int man_low  :32;
    329     unsigned int man_high :20;
    330     unsigned int exp      :11;
    331     unsigned int sign     :1;
    332   } bits;
    333 };
    334 
    335 
    336 union IeeeDoubleBigEndianArchType {
    337   double d;
    338   struct {
    339     unsigned int sign     :1;
    340     unsigned int exp      :11;
    341     unsigned int man_high :20;
    342     unsigned int man_low  :32;
    343   } bits;
    344 };
    345 
    346 
    347 // AccessorCallback
    348 struct AccessorDescriptor {
    349   MaybeObject* (*getter)(Object* object, void* data);
    350   MaybeObject* (*setter)(JSObject* object, Object* value, void* data);
    351   void* data;
    352 };
    353 
    354 
    355 // Logging and profiling.  A StateTag represents a possible state of
    356 // the VM. The logger maintains a stack of these. Creating a VMState
    357 // object enters a state by pushing on the stack, and destroying a
    358 // VMState object leaves a state by popping the current state from the
    359 // stack.
    360 
    361 enum StateTag {
    362   JS,
    363   GC,
    364   COMPILER,
    365   OTHER,
    366   EXTERNAL,
    367   IDLE
    368 };
    369 
    370 
    371 // -----------------------------------------------------------------------------
    372 // Macros
    373 
    374 // Testers for test.
    375 
    376 #define HAS_SMI_TAG(value) \
    377   ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag)
    378 
    379 #define HAS_FAILURE_TAG(value) \
    380   ((reinterpret_cast<intptr_t>(value) & kFailureTagMask) == kFailureTag)
    381 
    382 // OBJECT_POINTER_ALIGN returns the value aligned as a HeapObject pointer
    383 #define OBJECT_POINTER_ALIGN(value)                             \
    384   (((value) + kObjectAlignmentMask) & ~kObjectAlignmentMask)
    385 
    386 // POINTER_SIZE_ALIGN returns the value aligned as a pointer.
    387 #define POINTER_SIZE_ALIGN(value)                               \
    388   (((value) + kPointerAlignmentMask) & ~kPointerAlignmentMask)
    389 
    390 // CODE_POINTER_ALIGN returns the value aligned as a generated code segment.
    391 #define CODE_POINTER_ALIGN(value)                               \
    392   (((value) + kCodeAlignmentMask) & ~kCodeAlignmentMask)
    393 
    394 // Support for tracking C++ memory allocation.  Insert TRACK_MEMORY("Fisk")
    395 // inside a C++ class and new and delete will be overloaded so logging is
    396 // performed.
    397 // This file (globals.h) is included before log.h, so we use direct calls to
    398 // the Logger rather than the LOG macro.
    399 #ifdef DEBUG
    400 #define TRACK_MEMORY(name) \
    401   void* operator new(size_t size) { \
    402     void* result = ::operator new(size); \
    403     Logger::NewEventStatic(name, result, size); \
    404     return result; \
    405   } \
    406   void operator delete(void* object) { \
    407     Logger::DeleteEventStatic(name, object); \
    408     ::operator delete(object); \
    409   }
    410 #else
    411 #define TRACK_MEMORY(name)
    412 #endif
    413 
    414 
    415 enum CpuImplementer {
    416   UNKNOWN_IMPLEMENTER,
    417   ARM_IMPLEMENTER,
    418   QUALCOMM_IMPLEMENTER
    419 };
    420 
    421 
    422 enum CpuPart {
    423   CPU_UNKNOWN,
    424   CORTEX_A15,
    425   CORTEX_A12,
    426   CORTEX_A9,
    427   CORTEX_A8,
    428   CORTEX_A7,
    429   CORTEX_A5
    430 };
    431 
    432 
    433 // Feature flags bit positions. They are mostly based on the CPUID spec.
    434 // (We assign CPUID itself to one of the currently reserved bits --
    435 // feel free to change this if needed.)
    436 // On X86/X64, values below 32 are bits in EDX, values above 32 are bits in ECX.
    437 enum CpuFeature { SSE4_1 = 32 + 19,  // x86
    438                   SSE3 = 32 + 0,     // x86
    439                   SSE2 = 26,   // x86
    440                   CMOV = 15,   // x86
    441                   RDTSC = 4,   // x86
    442                   CPUID = 10,  // x86
    443                   VFP3 = 1,    // ARM
    444                   ARMv7 = 2,   // ARM
    445                   SUDIV = 3,   // ARM
    446                   UNALIGNED_ACCESSES = 4,  // ARM
    447                   MOVW_MOVT_IMMEDIATE_LOADS = 5,  // ARM
    448                   VFP32DREGS = 6,  // ARM
    449                   NEON = 7,    // ARM
    450                   SAHF = 0,    // x86
    451                   FPU = 1};    // MIPS
    452 
    453 
    454 // Used to specify if a macro instruction must perform a smi check on tagged
    455 // values.
    456 enum SmiCheckType {
    457   DONT_DO_SMI_CHECK,
    458   DO_SMI_CHECK
    459 };
    460 
    461 
    462 // Used to specify whether a receiver is implicitly or explicitly
    463 // provided to a call.
    464 enum CallKind {
    465   CALL_AS_METHOD,
    466   CALL_AS_FUNCTION
    467 };
    468 
    469 
    470 enum ScopeType {
    471   EVAL_SCOPE,      // The top-level scope for an eval source.
    472   FUNCTION_SCOPE,  // The top-level scope for a function.
    473   MODULE_SCOPE,    // The scope introduced by a module literal
    474   GLOBAL_SCOPE,    // The top-level scope for a program or a top-level eval.
    475   CATCH_SCOPE,     // The scope introduced by catch.
    476   BLOCK_SCOPE,     // The scope introduced by a new block.
    477   WITH_SCOPE       // The scope introduced by with.
    478 };
    479 
    480 
    481 const uint32_t kHoleNanUpper32 = 0x7FFFFFFF;
    482 const uint32_t kHoleNanLower32 = 0xFFFFFFFF;
    483 const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000;
    484 
    485 const uint64_t kHoleNanInt64 =
    486     (static_cast<uint64_t>(kHoleNanUpper32) << 32) | kHoleNanLower32;
    487 const uint64_t kLastNonNaNInt64 =
    488     (static_cast<uint64_t>(kNaNOrInfinityLowerBoundUpper32) << 32);
    489 
    490 
    491 // The order of this enum has to be kept in sync with the predicates below.
    492 enum VariableMode {
    493   // User declared variables:
    494   VAR,             // declared via 'var', and 'function' declarations
    495 
    496   CONST,           // declared via 'const' declarations
    497 
    498   LET,             // declared via 'let' declarations (first lexical)
    499 
    500   CONST_HARMONY,   // declared via 'const' declarations in harmony mode
    501 
    502   MODULE,          // declared via 'module' declaration (last lexical)
    503 
    504   // Variables introduced by the compiler:
    505   INTERNAL,        // like VAR, but not user-visible (may or may not
    506                    // be in a context)
    507 
    508   TEMPORARY,       // temporary variables (not user-visible), stack-allocated
    509                    // unless the scope as a whole has forced context allocation
    510 
    511   DYNAMIC,         // always require dynamic lookup (we don't know
    512                    // the declaration)
    513 
    514   DYNAMIC_GLOBAL,  // requires dynamic lookup, but we know that the
    515                    // variable is global unless it has been shadowed
    516                    // by an eval-introduced variable
    517 
    518   DYNAMIC_LOCAL    // requires dynamic lookup, but we know that the
    519                    // variable is local and where it is unless it
    520                    // has been shadowed by an eval-introduced
    521                    // variable
    522 };
    523 
    524 
    525 inline bool IsDynamicVariableMode(VariableMode mode) {
    526   return mode >= DYNAMIC && mode <= DYNAMIC_LOCAL;
    527 }
    528 
    529 
    530 inline bool IsDeclaredVariableMode(VariableMode mode) {
    531   return mode >= VAR && mode <= MODULE;
    532 }
    533 
    534 
    535 inline bool IsLexicalVariableMode(VariableMode mode) {
    536   return mode >= LET && mode <= MODULE;
    537 }
    538 
    539 
    540 inline bool IsImmutableVariableMode(VariableMode mode) {
    541   return mode == CONST || (mode >= CONST_HARMONY && mode <= MODULE);
    542 }
    543 
    544 
    545 // ES6 Draft Rev3 10.2 specifies declarative environment records with mutable
    546 // and immutable bindings that can be in two states: initialized and
    547 // uninitialized. In ES5 only immutable bindings have these two states. When
    548 // accessing a binding, it needs to be checked for initialization. However in
    549 // the following cases the binding is initialized immediately after creation
    550 // so the initialization check can always be skipped:
    551 // 1. Var declared local variables.
    552 //      var foo;
    553 // 2. A local variable introduced by a function declaration.
    554 //      function foo() {}
    555 // 3. Parameters
    556 //      function x(foo) {}
    557 // 4. Catch bound variables.
    558 //      try {} catch (foo) {}
    559 // 6. Function variables of named function expressions.
    560 //      var x = function foo() {}
    561 // 7. Implicit binding of 'this'.
    562 // 8. Implicit binding of 'arguments' in functions.
    563 //
    564 // ES5 specified object environment records which are introduced by ES elements
    565 // such as Program and WithStatement that associate identifier bindings with the
    566 // properties of some object. In the specification only mutable bindings exist
    567 // (which may be non-writable) and have no distinct initialization step. However
    568 // V8 allows const declarations in global code with distinct creation and
    569 // initialization steps which are represented by non-writable properties in the
    570 // global object. As a result also these bindings need to be checked for
    571 // initialization.
    572 //
    573 // The following enum specifies a flag that indicates if the binding needs a
    574 // distinct initialization step (kNeedsInitialization) or if the binding is
    575 // immediately initialized upon creation (kCreatedInitialized).
    576 enum InitializationFlag {
    577   kNeedsInitialization,
    578   kCreatedInitialized
    579 };
    580 
    581 
    582 enum ClearExceptionFlag {
    583   KEEP_EXCEPTION,
    584   CLEAR_EXCEPTION
    585 };
    586 
    587 
    588 } }  // namespace v8::internal
    589 
    590 #endif  // V8_V8GLOBALS_H_
    591