diff options
Diffstat (limited to 'chromium/v8/src/globals.h')
| -rw-r--r-- | chromium/v8/src/globals.h | 756 |
1 files changed, 549 insertions, 207 deletions
diff --git a/chromium/v8/src/globals.h b/chromium/v8/src/globals.h index 2f526a83bbe..595ecc37cfe 100644 --- a/chromium/v8/src/globals.h +++ b/chromium/v8/src/globals.h @@ -1,34 +1,15 @@ // Copyright 2012 the V8 project authors. All rights reserved. -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following -// disclaimer in the documentation and/or other materials provided -// with the distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. #ifndef V8_GLOBALS_H_ #define V8_GLOBALS_H_ -#include "../include/v8stdint.h" +#include "include/v8stdint.h" + +#include "src/base/build_config.h" +#include "src/base/macros.h" +#include "src/checks.h" // Unfortunately, the INFINITY macro cannot be used with the '-pedantic' // warning flag and certain versions of GCC due to a bug: @@ -38,7 +19,7 @@ #if V8_CC_GNU && V8_GNUC_PREREQ(2, 96, 0) && !V8_GNUC_PREREQ(4, 1, 0) # include <limits> // NOLINT # define V8_INFINITY std::numeric_limits<double>::infinity() -#elif V8_CC_MSVC +#elif V8_LIBC_MSVCRT # define V8_INFINITY HUGE_VAL #else # define V8_INFINITY INFINITY @@ -47,86 +28,13 @@ namespace v8 { namespace internal { -// Processor architecture detection. For more info on what's defined, see: -// http://msdn.microsoft.com/en-us/library/b0084kay.aspx -// http://www.agner.org/optimize/calling_conventions.pdf -// or with gcc, run: "echo | gcc -E -dM -" -#if defined(_M_X64) || defined(__x86_64__) -#if defined(__native_client__) -// For Native Client builds of V8, use V8_TARGET_ARCH_ARM, so that V8 -// generates ARM machine code, together with a portable ARM simulator -// compiled for the host architecture in question. -// -// Since Native Client is ILP-32 on all architectures we use -// V8_HOST_ARCH_IA32 on both 32- and 64-bit x86. -#define V8_HOST_ARCH_IA32 1 -#define V8_HOST_ARCH_32_BIT 1 -#define V8_HOST_CAN_READ_UNALIGNED 1 -#else -#define V8_HOST_ARCH_X64 1 -#define V8_HOST_ARCH_64_BIT 1 -#define V8_HOST_CAN_READ_UNALIGNED 1 -#endif // __native_client__ -#elif defined(_M_IX86) || defined(__i386__) -#define V8_HOST_ARCH_IA32 1 -#define V8_HOST_ARCH_32_BIT 1 -#define V8_HOST_CAN_READ_UNALIGNED 1 -#elif defined(__ARMEL__) -#define V8_HOST_ARCH_ARM 1 -#define V8_HOST_ARCH_32_BIT 1 -#elif defined(__MIPSEL__) -#define V8_HOST_ARCH_MIPS 1 -#define V8_HOST_ARCH_32_BIT 1 -#else -#error Host architecture was not detected as supported by v8 -#endif - -#if defined(__ARM_ARCH_7A__) || \ - defined(__ARM_ARCH_7R__) || \ - defined(__ARM_ARCH_7__) -# define CAN_USE_ARMV7_INSTRUCTIONS 1 -# ifndef CAN_USE_VFP3_INSTRUCTIONS -# define CAN_USE_VFP3_INSTRUCTIONS -# endif -#endif - - -// Target architecture detection. This may be set externally. If not, detect -// in the same way as the host architecture, that is, target the native -// environment as presented by the compiler. -#if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && \ - !V8_TARGET_ARCH_ARM && !V8_TARGET_ARCH_MIPS -#if defined(_M_X64) || defined(__x86_64__) -#define V8_TARGET_ARCH_X64 1 -#elif defined(_M_IX86) || defined(__i386__) -#define V8_TARGET_ARCH_IA32 1 -#elif defined(__ARMEL__) -#define V8_TARGET_ARCH_ARM 1 -#elif defined(__MIPSEL__) -#define V8_TARGET_ARCH_MIPS 1 -#else -#error Target architecture was not detected as supported by v8 -#endif -#endif - -// Check for supported combinations of host and target architectures. -#if V8_TARGET_ARCH_IA32 && !V8_HOST_ARCH_IA32 -#error Target architecture ia32 is only supported on ia32 host -#endif -#if V8_TARGET_ARCH_X64 && !V8_HOST_ARCH_X64 -#error Target architecture x64 is only supported on x64 host -#endif -#if (V8_TARGET_ARCH_ARM && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_ARM)) -#error Target architecture arm is only supported on arm and ia32 host -#endif -#if (V8_TARGET_ARCH_MIPS && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_MIPS)) -#error Target architecture mips is only supported on mips and ia32 host -#endif - // Determine whether we are running in a simulated environment. // Setting USE_SIMULATOR explicitly from the build script will force // the use of a simulated environment. #if !defined(USE_SIMULATOR) +#if (V8_TARGET_ARCH_ARM64 && !V8_HOST_ARCH_ARM64) +#define USE_SIMULATOR 1 +#endif #if (V8_TARGET_ARCH_ARM && !V8_HOST_ARCH_ARM) #define USE_SIMULATOR 1 #endif @@ -135,18 +43,8 @@ namespace internal { #endif #endif -// Determine architecture endiannes (we only support little-endian). -#if V8_TARGET_ARCH_IA32 -#define V8_TARGET_LITTLE_ENDIAN 1 -#elif V8_TARGET_ARCH_X64 -#define V8_TARGET_LITTLE_ENDIAN 1 -#elif V8_TARGET_ARCH_ARM -#define V8_TARGET_LITTLE_ENDIAN 1 -#elif V8_TARGET_ARCH_MIPS -#define V8_TARGET_LITTLE_ENDIAN 1 -#else -#error Unknown target architecture endiannes -#endif +// Determine whether the architecture uses an out-of-line constant pool. +#define V8_OOL_CONSTANT_POOL 0 // Support for alternative bool type. This is only enabled if the code is // compiled with USE_MYBOOL defined. This catches some nasty type bugs. @@ -203,11 +101,6 @@ typedef byte* Address; # define V8_PTR_PREFIX "" #endif -// The following macro works on both 32 and 64-bit platforms. -// Usage: instead of writing 0x1234567890123456 -// write V8_2PART_UINT64_C(0x12345678,90123456); -#define V8_2PART_UINT64_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u)) - #define V8PRIxPTR V8_PTR_PREFIX "x" #define V8PRIdPTR V8_PTR_PREFIX "d" #define V8PRIuPTR V8_PTR_PREFIX "u" @@ -218,10 +111,6 @@ typedef byte* Address; #define V8PRIxPTR "lx" #endif -#if V8_OS_MACOSX || defined(__FreeBSD__) || defined(__OpenBSD__) -#define USING_BSD_ABI -#endif - // ----------------------------------------------------------------------------- // Constants @@ -259,12 +148,14 @@ const int kDoubleSizeLog2 = 3; const int kPointerSizeLog2 = 3; const intptr_t kIntptrSignBit = V8_INT64_C(0x8000000000000000); const uintptr_t kUintptrAllBitsSet = V8_UINT64_C(0xFFFFFFFFFFFFFFFF); -const bool kIs64BitArch = true; +const bool kRequiresCodeRange = true; +const size_t kMaximalCodeRangeSize = 512 * MB; #else const int kPointerSizeLog2 = 2; const intptr_t kIntptrSignBit = 0x80000000; const uintptr_t kUintptrAllBitsSet = 0xFFFFFFFFu; -const bool kIs64BitArch = false; +const bool kRequiresCodeRange = false; +const size_t kMaximalCodeRangeSize = 0 * MB; #endif const int kBitsPerByte = 8; @@ -299,31 +190,6 @@ const int kUC16Size = sizeof(uc16); // NOLINT #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1)) -// The expression OFFSET_OF(type, field) computes the byte-offset -// of the specified field relative to the containing type. This -// corresponds to 'offsetof' (in stddef.h), except that it doesn't -// use 0 or NULL, which causes a problem with the compiler warnings -// we have enabled (which is also why 'offsetof' doesn't seem to work). -// Here we simply use the non-zero value 4, which seems to work. -#define OFFSET_OF(type, field) \ - (reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(4)->field)) - 4) - - -// The expression ARRAY_SIZE(a) is a compile-time constant of type -// size_t which represents the number of elements of the given -// array. You should only use ARRAY_SIZE on statically allocated -// arrays. -#define ARRAY_SIZE(a) \ - ((sizeof(a) / sizeof(*(a))) / \ - static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) - - -// The USE(x) template is used to silence C++ compiler warnings -// issued for (yet) unused variables (typically parameters). -template <typename T> -inline void USE(T) { } - - // FUNCTION_ADDR(f) gets the address of a C function f. #define FUNCTION_ADDR(f) \ (reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(f))) @@ -337,86 +203,562 @@ F FUNCTION_CAST(Address addr) { } -// A macro to disallow the evil copy constructor and operator= functions -// This should be used in the private: declarations for a class -#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&) V8_DELETE; \ - void operator=(const TypeName&) V8_DELETE - - -// A macro to disallow all the implicit constructors, namely the -// default constructor, copy constructor and operator= functions. -// -// This should be used in the private: declarations for a class -// that wants to prevent anyone from instantiating it. This is -// especially useful for classes containing only static methods. -#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ - TypeName() V8_DELETE; \ - DISALLOW_COPY_AND_ASSIGN(TypeName) +// ----------------------------------------------------------------------------- +// Forward declarations for frequently used classes +// (sorted alphabetically) +class FreeStoreAllocationPolicy; +template <typename T, class P = FreeStoreAllocationPolicy> class List; -// Newly written code should use V8_INLINE and V8_NOINLINE directly. -#define INLINE(declarator) V8_INLINE declarator -#define NO_INLINE(declarator) V8_NOINLINE declarator +// ----------------------------------------------------------------------------- +// Declarations for use in both the preparser and the rest of V8. +// The Strict Mode (ECMA-262 5th edition, 4.2.2). -// Newly written code should use V8_WARN_UNUSED_RESULT. -#define MUST_USE_RESULT V8_WARN_UNUSED_RESULT +enum StrictMode { SLOPPY, STRICT }; + + +// Mask for the sign bit in a smi. +const intptr_t kSmiSignMask = kIntptrSignBit; + +const int kObjectAlignmentBits = kPointerSizeLog2; +const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits; +const intptr_t kObjectAlignmentMask = kObjectAlignment - 1; + +// Desired alignment for pointers. +const intptr_t kPointerAlignment = (1 << kPointerSizeLog2); +const intptr_t kPointerAlignmentMask = kPointerAlignment - 1; + +// Desired alignment for double values. +const intptr_t kDoubleAlignment = 8; +const intptr_t kDoubleAlignmentMask = kDoubleAlignment - 1; + +// Desired alignment for generated code is 32 bytes (to improve cache line +// utilization). +const int kCodeAlignmentBits = 5; +const intptr_t kCodeAlignment = 1 << kCodeAlignmentBits; +const intptr_t kCodeAlignmentMask = kCodeAlignment - 1; + +// Tag information for Failure. +// TODO(yangguo): remove this from space owner calculation. +const int kFailureTag = 3; +const int kFailureTagSize = 2; +const intptr_t kFailureTagMask = (1 << kFailureTagSize) - 1; + + +// Zap-value: The value used for zapping dead objects. +// Should be a recognizable hex value tagged as a failure. +#ifdef V8_HOST_ARCH_64_BIT +const Address kZapValue = + reinterpret_cast<Address>(V8_UINT64_C(0xdeadbeedbeadbeef)); +const Address kHandleZapValue = + reinterpret_cast<Address>(V8_UINT64_C(0x1baddead0baddeaf)); +const Address kGlobalHandleZapValue = + reinterpret_cast<Address>(V8_UINT64_C(0x1baffed00baffedf)); +const Address kFromSpaceZapValue = + reinterpret_cast<Address>(V8_UINT64_C(0x1beefdad0beefdaf)); +const uint64_t kDebugZapValue = V8_UINT64_C(0xbadbaddbbadbaddb); +const uint64_t kSlotsZapValue = V8_UINT64_C(0xbeefdeadbeefdeef); +const uint64_t kFreeListZapValue = 0xfeed1eaffeed1eaf; +#else +const Address kZapValue = reinterpret_cast<Address>(0xdeadbeef); +const Address kHandleZapValue = reinterpret_cast<Address>(0xbaddeaf); +const Address kGlobalHandleZapValue = reinterpret_cast<Address>(0xbaffedf); +const Address kFromSpaceZapValue = reinterpret_cast<Address>(0xbeefdaf); +const uint32_t kSlotsZapValue = 0xbeefdeef; +const uint32_t kDebugZapValue = 0xbadbaddb; +const uint32_t kFreeListZapValue = 0xfeed1eaf; +#endif +const int kCodeZapValue = 0xbadc0de; -// Define DISABLE_ASAN macros. -#if defined(__has_feature) -#if __has_feature(address_sanitizer) -#define DISABLE_ASAN __attribute__((no_sanitize_address)) -#endif -#endif +// Number of bits to represent the page size for paged spaces. The value of 20 +// gives 1Mb bytes per page. +const int kPageSizeBits = 20; +// On Intel architecture, cache line size is 64 bytes. +// On ARM it may be less (32 bytes), but as far this constant is +// used for aligning data, it doesn't hurt to align on a greater value. +#define PROCESSOR_CACHE_LINE_SIZE 64 -#ifndef DISABLE_ASAN -#define DISABLE_ASAN -#endif +// Constants relevant to double precision floating point numbers. +// If looking only at the top 32 bits, the QNaN mask is bits 19 to 30. +const uint32_t kQuietNaNHighBitsMask = 0xfff << (51 - 32); // ----------------------------------------------------------------------------- // Forward declarations for frequently used classes -// (sorted alphabetically) -class FreeStoreAllocationPolicy; -template <typename T, class P = FreeStoreAllocationPolicy> class List; +class AccessorInfo; +class Allocation; +class Arguments; +class Assembler; +class Code; +class CodeGenerator; +class CodeStub; +class Context; +class Debug; +class Debugger; +class DebugInfo; +class Descriptor; +class DescriptorArray; +class TransitionArray; +class ExternalReference; +class FixedArray; +class FunctionTemplateInfo; +class MemoryChunk; +class SeededNumberDictionary; +class UnseededNumberDictionary; +class NameDictionary; +template <typename T> class MaybeHandle; +template <typename T> class Handle; +class Heap; +class HeapObject; +class IC; +class InterceptorInfo; +class Isolate; +class JSReceiver; +class JSArray; +class JSFunction; +class JSObject; +class LargeObjectSpace; +class LookupResult; +class MacroAssembler; +class Map; +class MapSpace; +class MarkCompactCollector; +class NewSpace; +class Object; +class OldSpace; +class Foreign; +class Scope; +class ScopeInfo; +class Script; +class Smi; +template <typename Config, class Allocator = FreeStoreAllocationPolicy> + class SplayTree; +class String; +class Name; +class Struct; +class Variable; +class RelocInfo; +class Deserializer; +class MessageLocation; +class VirtualMemory; +class Mutex; +class RecursiveMutex; + +typedef bool (*WeakSlotCallback)(Object** pointer); + +typedef bool (*WeakSlotCallbackWithHeap)(Heap* heap, Object** pointer); // ----------------------------------------------------------------------------- -// Declarations for use in both the preparser and the rest of V8. +// Miscellaneous + +// NOTE: SpaceIterator depends on AllocationSpace enumeration values being +// consecutive. +enum AllocationSpace { + NEW_SPACE, // Semispaces collected with copying collector. + OLD_POINTER_SPACE, // May contain pointers to new space. + OLD_DATA_SPACE, // Must not have pointers to new space. + CODE_SPACE, // No pointers to new space, marked executable. + MAP_SPACE, // Only and all map objects. + CELL_SPACE, // Only and all cell objects. + PROPERTY_CELL_SPACE, // Only and all global property cell objects. + LO_SPACE, // Promoted large objects. + INVALID_SPACE, // Only used in AllocationResult to signal success. + + FIRST_SPACE = NEW_SPACE, + LAST_SPACE = LO_SPACE, + FIRST_PAGED_SPACE = OLD_POINTER_SPACE, + LAST_PAGED_SPACE = PROPERTY_CELL_SPACE +}; +const int kSpaceTagSize = 3; +const int kSpaceTagMask = (1 << kSpaceTagSize) - 1; -// The different language modes that V8 implements. ES5 defines two language -// modes: an unrestricted mode respectively a strict mode which are indicated by -// CLASSIC_MODE respectively STRICT_MODE in the enum. The harmony spec drafts -// for the next ES standard specify a new third mode which is called 'extended -// mode'. The extended mode is only available if the harmony flag is set. It is -// based on the 'strict mode' and adds new functionality to it. This means that -// most of the semantics of these two modes coincide. + +// A flag that indicates whether objects should be pretenured when +// allocated (allocated directly into the old generation) or not +// (allocated in the young generation if the object size and type +// allows). +enum PretenureFlag { NOT_TENURED, TENURED }; + +enum MinimumCapacity { + USE_DEFAULT_MINIMUM_CAPACITY, + USE_CUSTOM_MINIMUM_CAPACITY +}; + +enum GarbageCollector { SCAVENGER, MARK_COMPACTOR }; + +enum Executability { NOT_EXECUTABLE, EXECUTABLE }; + +enum VisitMode { + VISIT_ALL, + VISIT_ALL_IN_SCAVENGE, + VISIT_ALL_IN_SWEEP_NEWSPACE, + VISIT_ONLY_STRONG +}; + +// Flag indicating whether code is built into the VM (one of the natives files). +enum NativesFlag { NOT_NATIVES_CODE, NATIVES_CODE }; + + +// A CodeDesc describes a buffer holding instructions and relocation +// information. The instructions start at the beginning of the buffer +// and grow forward, the relocation information starts at the end of +// the buffer and grows backward. // -// In the current draft the term 'base code' is used to refer to code that is -// neither in strict nor extended mode. However, the more distinguishing term -// 'classic mode' is used in V8 instead to avoid mix-ups. - -enum LanguageMode { - CLASSIC_MODE, - STRICT_MODE, - EXTENDED_MODE +// |<--------------- buffer_size ---------------->| +// |<-- instr_size -->| |<-- reloc_size -->| +// +==================+========+==================+ +// | instructions | free | reloc info | +// +==================+========+==================+ +// ^ +// | +// buffer + +struct CodeDesc { + byte* buffer; + int buffer_size; + int instr_size; + int reloc_size; + Assembler* origin; }; -// The Strict Mode (ECMA-262 5th edition, 4.2.2). +// Callback function used for iterating objects in heap spaces, +// for example, scanning heap objects. +typedef int (*HeapObjectCallback)(HeapObject* obj); + + +// Callback function used for checking constraints when copying/relocating +// objects. Returns true if an object can be copied/relocated from its +// old_addr to a new_addr. +typedef bool (*ConstraintCallback)(Address new_addr, Address old_addr); + + +// Callback function on inline caches, used for iterating over inline caches +// in compiled code. +typedef void (*InlineCacheCallback)(Code* code, Address ic); + + +// State for inline cache call sites. Aliased as IC::State. +enum InlineCacheState { + // Has never been executed. + UNINITIALIZED, + // Has been executed but monomorhic state has been delayed. + PREMONOMORPHIC, + // Has been executed and only one receiver type has been seen. + MONOMORPHIC, + // Like MONOMORPHIC but check failed due to prototype. + MONOMORPHIC_PROTOTYPE_FAILURE, + // Multiple receiver types have been seen. + POLYMORPHIC, + // Many receiver types have been seen. + MEGAMORPHIC, + // A generic handler is installed and no extra typefeedback is recorded. + GENERIC, + // Special state for debug break or step in prepare stubs. + DEBUG_STUB +}; + + +enum CallFunctionFlags { + NO_CALL_FUNCTION_FLAGS, + CALL_AS_METHOD, + // Always wrap the receiver and call to the JSFunction. Only use this flag + // both the receiver type and the target method are statically known. + WRAP_AND_CALL +}; + + +enum CallConstructorFlags { + NO_CALL_CONSTRUCTOR_FLAGS, + // The call target is cached in the instruction stream. + RECORD_CONSTRUCTOR_TARGET +}; + + +enum InlineCacheHolderFlag { + OWN_MAP, // For fast properties objects. + PROTOTYPE_MAP // For slow properties objects (except GlobalObjects). +}; + + +// The Store Buffer (GC). +typedef enum { + kStoreBufferFullEvent, + kStoreBufferStartScanningPagesEvent, + kStoreBufferScanningPageEvent +} StoreBufferEvent; + + +typedef void (*StoreBufferCallback)(Heap* heap, + MemoryChunk* page, + StoreBufferEvent event); + + +// Union used for fast testing of specific double values. +union DoubleRepresentation { + double value; + int64_t bits; + DoubleRepresentation(double x) { value = x; } + bool operator==(const DoubleRepresentation& other) const { + return bits == other.bits; + } +}; + + +// Union used for customized checking of the IEEE double types +// inlined within v8 runtime, rather than going to the underlying +// platform headers and libraries +union IeeeDoubleLittleEndianArchType { + double d; + struct { + unsigned int man_low :32; + unsigned int man_high :20; + unsigned int exp :11; + unsigned int sign :1; + } bits; +}; + + +union IeeeDoubleBigEndianArchType { + double d; + struct { + unsigned int sign :1; + unsigned int exp :11; + unsigned int man_high :20; + unsigned int man_low :32; + } bits; +}; + + +// AccessorCallback +struct AccessorDescriptor { + Object* (*getter)(Isolate* isolate, Object* object, void* data); + Object* (*setter)( + Isolate* isolate, JSObject* object, Object* value, void* data); + void* data; +}; + + +// Logging and profiling. A StateTag represents a possible state of +// the VM. The logger maintains a stack of these. Creating a VMState +// object enters a state by pushing on the stack, and destroying a +// VMState object leaves a state by popping the current state from the +// stack. + +enum StateTag { + JS, + GC, + COMPILER, + OTHER, + EXTERNAL, + IDLE +}; + + +// ----------------------------------------------------------------------------- +// Macros + +// Testers for test. + +#define HAS_SMI_TAG(value) \ + ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag) + +#define HAS_FAILURE_TAG(value) \ + ((reinterpret_cast<intptr_t>(value) & kFailureTagMask) == kFailureTag) + +// OBJECT_POINTER_ALIGN returns the value aligned as a HeapObject pointer +#define OBJECT_POINTER_ALIGN(value) \ + (((value) + kObjectAlignmentMask) & ~kObjectAlignmentMask) + +// POINTER_SIZE_ALIGN returns the value aligned as a pointer. +#define POINTER_SIZE_ALIGN(value) \ + (((value) + kPointerAlignmentMask) & ~kPointerAlignmentMask) + +// CODE_POINTER_ALIGN returns the value aligned as a generated code segment. +#define CODE_POINTER_ALIGN(value) \ + (((value) + kCodeAlignmentMask) & ~kCodeAlignmentMask) + +// Support for tracking C++ memory allocation. Insert TRACK_MEMORY("Fisk") +// inside a C++ class and new and delete will be overloaded so logging is +// performed. +// This file (globals.h) is included before log.h, so we use direct calls to +// the Logger rather than the LOG macro. +#ifdef DEBUG +#define TRACK_MEMORY(name) \ + void* operator new(size_t size) { \ + void* result = ::operator new(size); \ + Logger::NewEventStatic(name, result, size); \ + return result; \ + } \ + void operator delete(void* object) { \ + Logger::DeleteEventStatic(name, object); \ + ::operator delete(object); \ + } +#else +#define TRACK_MEMORY(name) +#endif + + +// CPU feature flags. +enum CpuFeature { + // x86 + SSE4_1, + SSE3, + SAHF, + // ARM + VFP3, + ARMv7, + SUDIV, + MLS, + UNALIGNED_ACCESSES, + MOVW_MOVT_IMMEDIATE_LOADS, + VFP32DREGS, + NEON, + // MIPS + FPU, + // ARM64 + ALWAYS_ALIGN_CSP, + NUMBER_OF_CPU_FEATURES +}; + + +// Used to specify if a macro instruction must perform a smi check on tagged +// values. +enum SmiCheckType { + DONT_DO_SMI_CHECK, + DO_SMI_CHECK +}; + + +enum ScopeType { + EVAL_SCOPE, // The top-level scope for an eval source. + FUNCTION_SCOPE, // The top-level scope for a function. + MODULE_SCOPE, // The scope introduced by a module literal + GLOBAL_SCOPE, // The top-level scope for a program or a top-level eval. + CATCH_SCOPE, // The scope introduced by catch. + BLOCK_SCOPE, // The scope introduced by a new block. + WITH_SCOPE // The scope introduced by with. +}; + + +const uint32_t kHoleNanUpper32 = 0x7FFFFFFF; +const uint32_t kHoleNanLower32 = 0xFFFFFFFF; +const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000; + +const uint64_t kHoleNanInt64 = + (static_cast<uint64_t>(kHoleNanUpper32) << 32) | kHoleNanLower32; +const uint64_t kLastNonNaNInt64 = + (static_cast<uint64_t>(kNaNOrInfinityLowerBoundUpper32) << 32); + + +// The order of this enum has to be kept in sync with the predicates below. +enum VariableMode { + // User declared variables: + VAR, // declared via 'var', and 'function' declarations + + CONST_LEGACY, // declared via legacy 'const' declarations + + LET, // declared via 'let' declarations (first lexical) + + CONST, // declared via 'const' declarations + + MODULE, // declared via 'module' declaration (last lexical) + + // Variables introduced by the compiler: + INTERNAL, // like VAR, but not user-visible (may or may not + // be in a context) + + TEMPORARY, // temporary variables (not user-visible), stack-allocated + // unless the scope as a whole has forced context allocation + + DYNAMIC, // always require dynamic lookup (we don't know + // the declaration) + + DYNAMIC_GLOBAL, // requires dynamic lookup, but we know that the + // variable is global unless it has been shadowed + // by an eval-introduced variable + + DYNAMIC_LOCAL // requires dynamic lookup, but we know that the + // variable is local and where it is unless it + // has been shadowed by an eval-introduced + // variable +}; + + +inline bool IsDynamicVariableMode(VariableMode mode) { + return mode >= DYNAMIC && mode <= DYNAMIC_LOCAL; +} + + +inline bool IsDeclaredVariableMode(VariableMode mode) { + return mode >= VAR && mode <= MODULE; +} + + +inline bool IsLexicalVariableMode(VariableMode mode) { + return mode >= LET && mode <= MODULE; +} + + +inline bool IsImmutableVariableMode(VariableMode mode) { + return (mode >= CONST && mode <= MODULE) || mode == CONST_LEGACY; +} + + +// ES6 Draft Rev3 10.2 specifies declarative environment records with mutable +// and immutable bindings that can be in two states: initialized and +// uninitialized. In ES5 only immutable bindings have these two states. When +// accessing a binding, it needs to be checked for initialization. However in +// the following cases the binding is initialized immediately after creation +// so the initialization check can always be skipped: +// 1. Var declared local variables. +// var foo; +// 2. A local variable introduced by a function declaration. +// function foo() {} +// 3. Parameters +// function x(foo) {} +// 4. Catch bound variables. +// try {} catch (foo) {} +// 6. Function variables of named function expressions. +// var x = function foo() {} +// 7. Implicit binding of 'this'. +// 8. Implicit binding of 'arguments' in functions. +// +// ES5 specified object environment records which are introduced by ES elements +// such as Program and WithStatement that associate identifier bindings with the +// properties of some object. In the specification only mutable bindings exist +// (which may be non-writable) and have no distinct initialization step. However +// V8 allows const declarations in global code with distinct creation and +// initialization steps which are represented by non-writable properties in the +// global object. As a result also these bindings need to be checked for +// initialization. // -// This flag is used in the backend to represent the language mode. So far -// there is no semantic difference between the strict and the extended mode in -// the backend, so both modes are represented by the kStrictMode value. -enum StrictModeFlag { - kNonStrictMode, - kStrictMode +// The following enum specifies a flag that indicates if the binding needs a +// distinct initialization step (kNeedsInitialization) or if the binding is +// immediately initialized upon creation (kCreatedInitialized). +enum InitializationFlag { + kNeedsInitialization, + kCreatedInitialized }; +enum ClearExceptionFlag { + KEEP_EXCEPTION, + CLEAR_EXCEPTION +}; + + +enum MinusZeroMode { + TREAT_MINUS_ZERO_AS_ZERO, + FAIL_ON_MINUS_ZERO +}; + } } // namespace v8::internal +namespace i = v8::internal; + #endif // V8_GLOBALS_H_ |