The data contained in this repository can be downloaded to your computer using one of several clients.
Please see the documentation of your version control software client for more information.
Please select the desired protocol below to get the URL.
This URL has Read-Only access.
main_repo / deps / v8 / src / globals.h @ 40c0f755
History | View | Annotate | Download (16.9 KB)
1 |
// Copyright 2006-2008 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_GLOBALS_H_
|
29 |
#define V8_GLOBALS_H_
|
30 |
|
31 |
// -----------------------------------------------------------------------------
|
32 |
// Types
|
33 |
// Visual Studio C++ is missing the stdint.h header file. Instead we define
|
34 |
// standard integer types for Windows here.
|
35 |
|
36 |
#ifdef _MSC_VER
|
37 |
typedef signed char int8_t; |
38 |
typedef unsigned char uint8_t; |
39 |
typedef short int16_t; // NOLINT |
40 |
typedef unsigned short uint16_t; // NOLINT |
41 |
typedef int int32_t; |
42 |
typedef unsigned int uint32_t; |
43 |
typedef __int64 int64_t;
|
44 |
typedef unsigned __int64 uint64_t; |
45 |
#else // _MSC_VER |
46 |
#include <stdint.h> // for intptr_t |
47 |
#endif // _MSC_VER |
48 |
|
49 |
|
50 |
namespace v8 { namespace internal { |
51 |
|
52 |
// Support for alternative bool type. This is only enabled if the code is
|
53 |
// compiled with USE_MYBOOL defined. This catches some nasty type bugs.
|
54 |
// For instance, 'bool b = "false";' results in b == true! This is a hidden
|
55 |
// source of bugs.
|
56 |
// However, redefining the bool type does have some negative impact on some
|
57 |
// platforms. It gives rise to compiler warnings (i.e. with
|
58 |
// MSVC) in the API header files when mixing code that uses the standard
|
59 |
// bool with code that uses the redefined version.
|
60 |
// This does not actually belong in the platform code, but needs to be
|
61 |
// defined here because the platform code uses bool, and platform.h is
|
62 |
// include very early in the main include file.
|
63 |
|
64 |
#ifdef USE_MYBOOL
|
65 |
typedef unsigned int __my_bool__; |
66 |
#define bool __my_bool__ // use 'indirection' to avoid name clashes |
67 |
#endif
|
68 |
|
69 |
typedef uint8_t byte;
|
70 |
typedef byte* Address;
|
71 |
|
72 |
// Code-point values in Unicode 4.0 are 21 bits wide.
|
73 |
typedef uint16_t uc16;
|
74 |
typedef signed int uc32; |
75 |
|
76 |
#ifndef ARM
|
77 |
#define CAN_READ_UNALIGNED 1 |
78 |
#endif
|
79 |
|
80 |
// -----------------------------------------------------------------------------
|
81 |
// Constants
|
82 |
|
83 |
#ifdef DEBUG
|
84 |
const bool kDebug = true; |
85 |
#else
|
86 |
const bool kDebug = false; |
87 |
#endif // DEBUG |
88 |
|
89 |
const int KB = 1024; |
90 |
const int MB = KB * KB; |
91 |
const int GB = KB * KB * KB; |
92 |
const int kMaxInt = 0x7FFFFFFF; |
93 |
const int kMinInt = -kMaxInt - 1; |
94 |
|
95 |
const int kCharSize = sizeof(char); // NOLINT |
96 |
const int kShortSize = sizeof(short); // NOLINT |
97 |
const int kIntSize = sizeof(int); // NOLINT |
98 |
const int kDoubleSize = sizeof(double); // NOLINT |
99 |
const int kPointerSize = sizeof(void*); // NOLINT |
100 |
|
101 |
const int kPointerSizeLog2 = 2; |
102 |
|
103 |
const int kObjectAlignmentBits = 2; |
104 |
const int kObjectAlignmentMask = (1 << kObjectAlignmentBits) - 1; |
105 |
const int kObjectAlignment = 1 << kObjectAlignmentBits; |
106 |
|
107 |
|
108 |
// Tag information for HeapObject.
|
109 |
const int kHeapObjectTag = 1; |
110 |
const int kHeapObjectTagSize = 2; |
111 |
const int kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1; |
112 |
|
113 |
|
114 |
// Tag information for Smi.
|
115 |
const int kSmiTag = 0; |
116 |
const int kSmiTagSize = 1; |
117 |
const int kSmiTagMask = (1 << kSmiTagSize) - 1; |
118 |
|
119 |
|
120 |
// Tag information for Failure.
|
121 |
const int kFailureTag = 3; |
122 |
const int kFailureTagSize = 2; |
123 |
const int kFailureTagMask = (1 << kFailureTagSize) - 1; |
124 |
|
125 |
|
126 |
const int kBitsPerByte = 8; |
127 |
const int kBitsPerByteLog2 = 3; |
128 |
const int kBitsPerPointer = kPointerSize * kBitsPerByte; |
129 |
const int kBitsPerInt = kIntSize * kBitsPerByte; |
130 |
|
131 |
|
132 |
// Zap-value: The value used for zapping dead objects. Should be a recognizable
|
133 |
// illegal heap object pointer.
|
134 |
const Address kZapValue = reinterpret_cast<Address>(0xdeadbeed); |
135 |
const Address kHandleZapValue = reinterpret_cast<Address>(0xbaddead); |
136 |
const Address kFromSpaceZapValue = reinterpret_cast<Address>(0xbeefdad); |
137 |
|
138 |
// -----------------------------------------------------------------------------
|
139 |
// Forward declarations for frequently used classes
|
140 |
// (sorted alphabetically)
|
141 |
|
142 |
class AccessorInfo; |
143 |
class Allocation; |
144 |
class Arguments; |
145 |
class Assembler; |
146 |
class BreakableStatement; |
147 |
class Code; |
148 |
class CodeGenerator; |
149 |
class CodeRegion; |
150 |
class CodeStub; |
151 |
class Context; |
152 |
class Debug; |
153 |
class Debugger; |
154 |
class DebugInfo; |
155 |
class Descriptor; |
156 |
class DescriptorArray; |
157 |
class Expression; |
158 |
class ExternalReference; |
159 |
class FixedArray; |
160 |
class FunctionEntry; |
161 |
class FunctionLiteral; |
162 |
class FunctionTemplateInfo; |
163 |
class Dictionary; |
164 |
class FreeStoreAllocationPolicy; |
165 |
template <typename T> class Handle; |
166 |
class Heap; |
167 |
class HeapObject; |
168 |
class IC; |
169 |
class InterceptorInfo; |
170 |
class IterationStatement; |
171 |
class JSArray; |
172 |
class JSFunction; |
173 |
class JSObject; |
174 |
class LargeObjectSpace; |
175 |
template <typename T, class P = FreeStoreAllocationPolicy> class List; |
176 |
class LookupResult; |
177 |
class MacroAssembler; |
178 |
class Map; |
179 |
class MapSpace; |
180 |
class MarkCompactCollector; |
181 |
class NewSpace; |
182 |
class NodeVisitor; |
183 |
class Object; |
184 |
class OldSpace; |
185 |
class Property; |
186 |
class Proxy; |
187 |
class RegExpNode; |
188 |
struct RegExpCompileData;
|
189 |
class RegExpTree; |
190 |
class RegExpCompiler; |
191 |
class RegExpVisitor; |
192 |
class Scope; |
193 |
template<class Allocator = FreeStoreAllocationPolicy> class ScopeInfo; |
194 |
class Script; |
195 |
class Slot; |
196 |
class Smi; |
197 |
class Statement; |
198 |
class String; |
199 |
class Struct; |
200 |
class SwitchStatement; |
201 |
class AstVisitor; |
202 |
class Variable; |
203 |
class VariableProxy; |
204 |
class RelocInfo; |
205 |
class Deserializer; |
206 |
class MessageLocation; |
207 |
class ObjectGroup; |
208 |
class TickSample; |
209 |
class VirtualMemory; |
210 |
class Mutex; |
211 |
|
212 |
typedef bool (*WeakSlotCallback)(Object** pointer); |
213 |
|
214 |
// -----------------------------------------------------------------------------
|
215 |
// Miscellaneous
|
216 |
|
217 |
// NOTE: SpaceIterator depends on AllocationSpace enumeration values being
|
218 |
// consecutive.
|
219 |
enum AllocationSpace {
|
220 |
NEW_SPACE, // Semispaces collected with copying collector.
|
221 |
OLD_POINTER_SPACE, // Must be first of the paged spaces - see PagedSpaces.
|
222 |
OLD_DATA_SPACE, // May not have pointers to new space.
|
223 |
CODE_SPACE, // Also one of the old spaces. Marked executable.
|
224 |
MAP_SPACE, // Only map objects.
|
225 |
LO_SPACE, // Large objects.
|
226 |
FIRST_SPACE = NEW_SPACE, |
227 |
LAST_SPACE = LO_SPACE // <= 5 (see kSpaceBits and kLOSpacePointer)
|
228 |
}; |
229 |
const int kSpaceTagSize = 3; |
230 |
const int kSpaceTagMask = (1 << kSpaceTagSize) - 1; |
231 |
|
232 |
|
233 |
// A flag that indicates whether objects should be pretenured when
|
234 |
// allocated (allocated directly into the old generation) or not
|
235 |
// (allocated in the young generation if the object size and type
|
236 |
// allows).
|
237 |
enum PretenureFlag { NOT_TENURED, TENURED };
|
238 |
|
239 |
enum GarbageCollector { SCAVENGER, MARK_COMPACTOR };
|
240 |
|
241 |
enum Executability { NOT_EXECUTABLE, EXECUTABLE };
|
242 |
|
243 |
|
244 |
// A CodeDesc describes a buffer holding instructions and relocation
|
245 |
// information. The instructions start at the beginning of the buffer
|
246 |
// and grow forward, the relocation information starts at the end of
|
247 |
// the buffer and grows backward.
|
248 |
//
|
249 |
// |<--------------- buffer_size ---------------->|
|
250 |
// |<-- instr_size -->| |<-- reloc_size -->|
|
251 |
// +==================+========+==================+
|
252 |
// | instructions | free | reloc info |
|
253 |
// +==================+========+==================+
|
254 |
// ^
|
255 |
// |
|
256 |
// buffer
|
257 |
|
258 |
struct CodeDesc {
|
259 |
byte* buffer; |
260 |
int buffer_size;
|
261 |
int instr_size;
|
262 |
int reloc_size;
|
263 |
Assembler* origin; |
264 |
}; |
265 |
|
266 |
|
267 |
// Callback function on object slots, used for iterating heap object slots in
|
268 |
// HeapObjects, global pointers to heap objects, etc. The callback allows the
|
269 |
// callback function to change the value of the slot.
|
270 |
typedef void (*ObjectSlotCallback)(HeapObject** pointer); |
271 |
|
272 |
|
273 |
// Callback function used for iterating objects in heap spaces,
|
274 |
// for example, scanning heap objects.
|
275 |
typedef int (*HeapObjectCallback)(HeapObject* obj); |
276 |
|
277 |
|
278 |
// Callback function used for checking constraints when copying/relocating
|
279 |
// objects. Returns true if an object can be copied/relocated from its
|
280 |
// old_addr to a new_addr.
|
281 |
typedef bool (*ConstraintCallback)(Address new_addr, Address old_addr); |
282 |
|
283 |
|
284 |
// Callback function on inline caches, used for iterating over inline caches
|
285 |
// in compiled code.
|
286 |
typedef void (*InlineCacheCallback)(Code* code, Address ic); |
287 |
|
288 |
|
289 |
// State for inline cache call sites. Aliased as IC::State.
|
290 |
enum InlineCacheState {
|
291 |
// Has never been executed.
|
292 |
UNINITIALIZED, |
293 |
// Has never been executed, but is in a loop.
|
294 |
UNINITIALIZED_IN_LOOP, |
295 |
// Has been executed but monomorhic state has been delayed.
|
296 |
PREMONOMORPHIC, |
297 |
// Has been executed and only one receiver type has been seen.
|
298 |
MONOMORPHIC, |
299 |
// Like MONOMORPHIC but check failed due to prototype.
|
300 |
MONOMORPHIC_PROTOTYPE_FAILURE, |
301 |
// Multiple receiver types have been seen.
|
302 |
MEGAMORPHIC, |
303 |
// Special states for debug break or step in prepare stubs.
|
304 |
DEBUG_BREAK, |
305 |
DEBUG_PREPARE_STEP_IN |
306 |
}; |
307 |
|
308 |
|
309 |
// Type of properties.
|
310 |
// Order of properties is significant.
|
311 |
// Must fit in the BitField PropertyDetails::TypeField.
|
312 |
// A copy of this is in mirror-delay.js.
|
313 |
enum PropertyType {
|
314 |
NORMAL = 0, // only in slow mode |
315 |
FIELD = 1, // only in fast mode |
316 |
CONSTANT_FUNCTION = 2, // only in fast mode |
317 |
CALLBACKS = 3,
|
318 |
INTERCEPTOR = 4, // only in lookup results, not in descriptors. |
319 |
MAP_TRANSITION = 5, // only in fast mode |
320 |
CONSTANT_TRANSITION = 6, // only in fast mode |
321 |
NULL_DESCRIPTOR = 7, // only in fast mode |
322 |
// All properties before MAP_TRANSITION are real.
|
323 |
FIRST_PHANTOM_PROPERTY_TYPE = MAP_TRANSITION |
324 |
}; |
325 |
|
326 |
|
327 |
// Whether to remove map transitions and constant transitions from a
|
328 |
// DescriptorArray.
|
329 |
enum TransitionFlag {
|
330 |
REMOVE_TRANSITIONS, |
331 |
KEEP_TRANSITIONS |
332 |
}; |
333 |
|
334 |
|
335 |
// Union used for fast testing of specific double values.
|
336 |
union DoubleRepresentation {
|
337 |
double value;
|
338 |
int64_t bits; |
339 |
DoubleRepresentation(double x) { value = x; }
|
340 |
}; |
341 |
|
342 |
|
343 |
// AccessorCallback
|
344 |
struct AccessorDescriptor {
|
345 |
Object* (*getter)(Object* object, void* data);
|
346 |
Object* (*setter)(JSObject* object, Object* value, void* data);
|
347 |
void* data;
|
348 |
}; |
349 |
|
350 |
|
351 |
// Logging and profiling.
|
352 |
// A StateTag represents a possible state of the VM. When compiled with
|
353 |
// ENABLE_LOGGING_AND_PROFILING, the logger maintains a stack of these.
|
354 |
// Creating a VMState object enters a state by pushing on the stack, and
|
355 |
// destroying a VMState object leaves a state by popping the current state
|
356 |
// from the stack.
|
357 |
|
358 |
#define STATE_TAG_LIST(V) \
|
359 |
V(JS) \ |
360 |
V(GC) \ |
361 |
V(COMPILER) \ |
362 |
V(OTHER) \ |
363 |
V(EXTERNAL) |
364 |
|
365 |
enum StateTag {
|
366 |
#define DEF_STATE_TAG(name) name,
|
367 |
STATE_TAG_LIST(DEF_STATE_TAG) |
368 |
#undef DEF_STATE_TAG
|
369 |
// Pseudo-types.
|
370 |
state_tag_count |
371 |
}; |
372 |
|
373 |
|
374 |
// -----------------------------------------------------------------------------
|
375 |
// Macros
|
376 |
|
377 |
// Testers for test.
|
378 |
|
379 |
#define HAS_SMI_TAG(value) \
|
380 |
((reinterpret_cast<int>(value) & kSmiTagMask) == kSmiTag)
|
381 |
|
382 |
#define HAS_FAILURE_TAG(value) \
|
383 |
((reinterpret_cast<int>(value) & kFailureTagMask) == kFailureTag)
|
384 |
|
385 |
#define HAS_HEAP_OBJECT_TAG(value) \
|
386 |
((reinterpret_cast<int>(value) & kHeapObjectTagMask) == kHeapObjectTag)
|
387 |
|
388 |
// OBJECT_SIZE_ALIGN returns the value aligned HeapObject size
|
389 |
#define OBJECT_SIZE_ALIGN(value) \
|
390 |
((value + kObjectAlignmentMask) & ~kObjectAlignmentMask) |
391 |
|
392 |
// The expression OFFSET_OF(type, field) computes the byte-offset
|
393 |
// of the specified field relative to the containing type. This
|
394 |
// corresponds to 'offsetof' (in stddef.h), except that it doesn't
|
395 |
// use 0 or NULL, which causes a problem with the compiler warnings
|
396 |
// we have enabled (which is also why 'offsetof' doesn't seem to work).
|
397 |
// Here we simply use the non-zero value 4, which seems to work.
|
398 |
#define OFFSET_OF(type, field) \
|
399 |
(reinterpret_cast<intptr_t>(&(reinterpret_cast<type*>(4)->field)) - 4) |
400 |
|
401 |
|
402 |
// The expression ARRAY_SIZE(a) is a compile-time constant of type
|
403 |
// size_t which represents the number of elements of the given
|
404 |
// array. You should only use ARRAY_SIZE on statically allocated
|
405 |
// arrays.
|
406 |
#define ARRAY_SIZE(a) \
|
407 |
((sizeof(a) / sizeof(*(a))) / \ |
408 |
static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) |
409 |
|
410 |
|
411 |
// The USE(x) template is used to silence C++ compiler warnings
|
412 |
// issued for (yet) unused variables (typically parameters).
|
413 |
template <typename T> |
414 |
static inline void USE(T) { } |
415 |
|
416 |
|
417 |
// FUNCTION_ADDR(f) gets the address of a C function f.
|
418 |
#define FUNCTION_ADDR(f) \
|
419 |
(reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(f))) |
420 |
|
421 |
|
422 |
// FUNCTION_CAST<F>(addr) casts an address into a function
|
423 |
// of type F. Used to invoke generated code from within C.
|
424 |
template <typename F> |
425 |
F FUNCTION_CAST(Address addr) { |
426 |
return reinterpret_cast<F>(reinterpret_cast<intptr_t>(addr));
|
427 |
} |
428 |
|
429 |
|
430 |
// A macro to disallow the evil copy constructor and operator= functions
|
431 |
// This should be used in the private: declarations for a class
|
432 |
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
|
433 |
TypeName(const TypeName&); \
|
434 |
void operator=(const TypeName&) |
435 |
|
436 |
|
437 |
// A macro to disallow all the implicit constructors, namely the
|
438 |
// default constructor, copy constructor and operator= functions.
|
439 |
//
|
440 |
// This should be used in the private: declarations for a class
|
441 |
// that wants to prevent anyone from instantiating it. This is
|
442 |
// especially useful for classes containing only static methods.
|
443 |
#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
|
444 |
TypeName(); \ |
445 |
DISALLOW_COPY_AND_ASSIGN(TypeName) |
446 |
|
447 |
|
448 |
// Support for tracking C++ memory allocation. Insert TRACK_MEMORY("Fisk")
|
449 |
// inside a C++ class and new and delete will be overloaded so logging is
|
450 |
// performed.
|
451 |
// This file (globals.h) is included before log.h, so we use direct calls to
|
452 |
// the Logger rather than the LOG macro.
|
453 |
#ifdef DEBUG
|
454 |
#define TRACK_MEMORY(name) \
|
455 |
void* operator new(size_t size) { \
|
456 |
void* result = ::operator new(size); \
|
457 |
Logger::NewEvent(name, result, size); \ |
458 |
return result; \
|
459 |
} \ |
460 |
void operator delete(void* object) { \ |
461 |
Logger::DeleteEvent(name, object); \ |
462 |
::operator delete(object); \ |
463 |
} |
464 |
#else
|
465 |
#define TRACK_MEMORY(name)
|
466 |
#endif
|
467 |
|
468 |
// define used for helping GCC to make better inlining. Don't bother for debug
|
469 |
// builds. On GCC 3.4.5 using __attribute__((always_inline)) causes compilation
|
470 |
// errors in debug build.
|
471 |
#if defined(__GNUC__) && !defined(DEBUG)
|
472 |
#if (__GNUC__ >= 4) |
473 |
#define INLINE(header) inline header __attribute__((always_inline)) |
474 |
#else
|
475 |
#define INLINE(header) inline __attribute__((always_inline)) header |
476 |
#endif
|
477 |
#else
|
478 |
#define INLINE(header) inline header |
479 |
#endif
|
480 |
|
481 |
// The type-based aliasing rule allows the compiler to assume that pointers of
|
482 |
// different types (for some definition of different) never alias each other.
|
483 |
// Thus the following code does not work:
|
484 |
//
|
485 |
// float f = foo();
|
486 |
// int fbits = *(int*)(&f);
|
487 |
//
|
488 |
// The compiler 'knows' that the int pointer can't refer to f since the types
|
489 |
// don't match, so the compiler may cache f in a register, leaving random data
|
490 |
// in fbits. Using C++ style casts makes no difference, however a pointer to
|
491 |
// char data is assumed to alias any other pointer. This is the 'memcpy
|
492 |
// exception'.
|
493 |
//
|
494 |
// Bit_cast uses the memcpy exception to move the bits from a variable of one
|
495 |
// type o a variable of another type. Of course the end result is likely to
|
496 |
// be implementation dependent. Most compilers (gcc-4.2 and MSVC 2005)
|
497 |
// will completely optimize bit_cast away.
|
498 |
//
|
499 |
// There is an additional use for bit_cast.
|
500 |
// Recent gccs will warn when they see casts that may result in breakage due to
|
501 |
// the type-based aliasing rule. If you have checked that there is no breakage
|
502 |
// you can use bit_cast to cast one pointer type to another. This confuses gcc
|
503 |
// enough that it can no longer see that you have cast one pointer type to
|
504 |
// another thus avoiding the warning.
|
505 |
template <class Dest, class Source> |
506 |
inline Dest bit_cast(const Source& source) { |
507 |
// Compile time assertion: sizeof(Dest) == sizeof(Source)
|
508 |
// A compile error here means your Dest and Source have different sizes.
|
509 |
typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1]; |
510 |
|
511 |
Dest dest; |
512 |
memcpy(&dest, &source, sizeof(dest));
|
513 |
return dest;
|
514 |
} |
515 |
|
516 |
|
517 |
} } // namespace v8::internal
|
518 |
|
519 |
#endif // V8_GLOBALS_H_ |